Xenon

https://github.com/xenondevs/docs
Admin
This repository contains documentation for Xenondevs projects, including Nova, InvUI, and CBF,...
Tokens:73,662
Snippets:484
Trust Score:7.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Create Test Instance of Example Data Class

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/codec.md

This snippet shows how to instantiate an Example data class with sample values, preparing it for serialization and deserialization testing with the defined codec.

```Kotlin
val testId = ResourceLocation("minecraft", "stone")
val test = Example(testId, listOf(1, 2, 3), "hello")
```

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

### Configure Project Distributors for Update Checks in Kotlin

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/migration-guide/0.13-0.14.md

The `spigotResourceId` has been removed. To check for updates, configure a list of `ProjectDistributors` directly in your addon's code. This example demonstrates setting up Hangar, Modrinth, and GitHub distributors.

```kotlin
object MyAddon : Addon() {
    
    override val projectDistributors = listOf(
        ProjectDistributor.hangar(/*project id*/), //(1)!
        ProjectDistributor.modrinth(/*project id*/), //(2)!
        ProjectDistributor.github(/*project id*/) //(3)!
    )

}
```

```kotlin
ProjectDistributor.hangar("xenondevs/Machines")
```

```kotlin
ProjectDistributor.modrinth("nova-framework")
```

```kotlin
ProjectDistributor.github("Nova-Addons/Machines")
```

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

### Complete Addon Configuration Example in Gradle Kotlin DSL

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/addon-configuration.md

This snippet provides a comprehensive example of configuring the `addon` block in a `build.gradle.kts` file. It demonstrates how to set essential properties like name, version, main class, authors, and dependencies within a single configuration block.

```Kotlin
addon {
    name.set("ExampleAddon")
    version.set("0.1")
    main.set("com.example.ExampleAddon")
    authors.set(listOf("Example Author", "Another Author"))
    dependency("machines")
}
```

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

### Serialized JSON Output of Example Instance

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/codec.md

This JSON snippet represents the serialized form of the Example data class instance, demonstrating the output structure when using the defined codec.

```JSON
{
  "id": "minecraft:stone",
  "ints": [1, 2, 3],
  "defaultString": "hello"
}
```

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

### Example Twisting Vines Feature Configuration and Placement

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/configurations/twisting-vines.md

Demonstrates how to configure and place the `twisting_vines` feature in the nether. This example shows both the feature configuration and its placement rules, including count, spread, height range, and biome filtering, presented in both Kotlin and JSON formats.

```Kotlin
@OptIn(ExperimentalWorldGen::class)
@Init(stage = InitStage.POST_PACK_PRE_WORLD)
object ConfiguredFeatures : FeatureRegistry by ExampleAddon.registry {

    val TWISTING_VINES = registerConfiguredFeature(
        "twisting_vines",
        Feature.TWISTING_VINES,
        TwistingVinesConfig(
            8, // spreadWidth
            4, // spreadHeight
            8 // maxHeight
        )
    )

}
```

```Kotlin
@OptIn(ExperimentalWorldGen::class)
@Init(stage = InitStage.POST_PACK_PRE_WORLD)
object PlacedFeatures : FeatureRegistry by ExampleAddon.registry {

    val TWISTING_VINES = placedFeature("twisting_vines", ConfiguredFeatures.TWISTING_VINES)
        .count(10) // (1)!
        .inSquareSpread() // (2)!
        .modifier(PlacementUtils.FULL_RANGE) // (3)!
        .biomeFilter() // (4)!
        .register()

}
```

```Json
{
   "type": "minecraft:twisting_vines",
   "config": {
      "spread_width": 8,
      "spread_height": 4,
      "max_height": 8
   }
}
```

```Json
{
   "feature": "minecraft:twisting_vines",
   "placement": [
      {
         "type": "minecraft:count", // (1)!
         "count": 10
      },
      {
         "type": "minecraft:in_square" // (2)!
      },
      {
         "type": "minecraft:height_range", // (3)!
         "height": {
            "type": "minecraft:uniform",
            "max_inclusive": {
               "below_top": 0
            },
            "min_inclusive": {
               "above_bottom": 0
            }
         }
      },
      {
         "type": "minecraft:biome" // (4)!
      }
   ]
}
```

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

### Example WAILA Positioning Configuration for Multiple Matchers

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/configuration.md

This comprehensive YAML example demonstrates how to combine multiple matcher types to achieve specific WAILA positioning. It shows how to place WAILA above all vanilla boss bars (`minecraft` origin) but below boss bars from `PluginA` and `PluginB` by using both `above` and `below` configurations.

```yaml
waila:
  positioning:
    above:
    - type: origin
      origin: minecraft
    below:
    - type: origin
      origin: PluginA
    - type: origin
      origin: PluginB
```

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

### Deserialized Example Instance with Default Value

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/codec.md

This output shows the deserialized Example instance when the 'defaultString' field is missing from the input JSON, confirming that the default value 'default' is correctly applied.

```Text
Example(id=minecraft:stone, ints=[1, 2, 3], defaultString=default)
```

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

### Example: Blacklist an Entire Directory from Resource Pack

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/configuration.md

This YAML example shows how to use a `blacklist` filter with a `regex` pattern (`.*`) to exclude an entire directory, specified by `path/to/directory/`, from being included in the generated resource pack.

```yaml
- stage: resource_pack
  type: blacklist
  pattern_type: regex
  filter: .*
  directory: path/to/directory/
```

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

### Complete Codec Definition for Example Data Class

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/codec.md

This comprehensive snippet combines individual field codecs using RecordCodecBuilder to define a full codec for the Example data class, mapping all fields to its constructor.

```Kotlin
val CODEC: Codec<Example> = RecordCodecBuilder.create { instance ->
   instance.group(
           ResourceLocation.CODEC.fieldOf("id").forGetter(Example::id),
           Codec.INT.listOf().fieldOf("ints").forGetter(Example::ints),
           Codec.STRING
              .optionalFieldOf("defaultString", "default")
              .forGetter(Example::defaultString)
   ).apply(instance, ::Example)
}
```

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

### Building Nova Addon Jar with Gradle

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/index.md

Illustrates the Gradle command to build the Nova addon into a JAR file. The `-PoutDir` argument specifies the output directory for the generated addon JAR.

```Bash
gradlew addonJar -PoutDir="<Path to your addons directory here>"
```

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

### Adding Runtime Dependencies to Nova Addon

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/index.md

Demonstrates how to add runtime dependencies to a Nova addon project using the `libraryLoader` configuration in `build.gradle.kts`. These libraries will be downloaded at startup, exposing all configured Maven repository URLs.

```Kotlin
libraryLoader("commons-net:commons-net:3.8.0")
```

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

### Example: Blacklist All PNG Files from Resource Pack

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/configuration.md

This YAML example illustrates using a `blacklist` filter with a `regex` pattern (`*.png`) to exclude all PNG image files from the entire resource pack during generation, regardless of their directory.

```yaml
- stage: resource_pack
  type: blacklist
  pattern_type: regex
  filter: *.png
```

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

### Vanilla Ore Placement Examples in Kotlin

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/configurations/ores.md

This section provides examples of how to use the defined ore placement utility functions to mimic vanilla Minecraft ore generation. It showcases configurations for iron and diamond ores, demonstrating different height ranges and placement strategies like `triangle` and `uniform`.

```Kotlin
// ore_iron_upper
commonOrePlacement(90, HeightRangePlacement.triangle(VerticalAnchor.absolute(80), VerticalAnchor.absolute(384)))
// ore_iron_middle
commonOrePlacement(10, HeightRangePlacement.triangle(VerticalAnchor.absolute(-24), VerticalAnchor.absolute(56)))
// ore_iron_small
commonOrePlacement(10, HeightRangePlacement.uniform(VerticalAnchor.bottom(), VerticalAnchor.absolute(72)))

// ore_diamond
commonOrePlacement(7, HeightRangePlacement.triangle(VerticalAnchor.aboveBottom(-80), VerticalAnchor.aboveBottom(80)))
// ore_diamond_large
rareOrePlacement(9, HeightRangePlacement.triangle(VerticalAnchor.aboveBottom(-80), VerticalAnchor.aboveBottom(80)))
// ore_diamond_buried
commonOrePlacement(4, HeightRangePlacement.triangle(VerticalAnchor.aboveBottom(-80), VerticalAnchor.aboveBottom(80)))
```

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

### InvUI Reactive Anvil Window Example in Kotlin

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/migration-guide/0.17-0.18.md

This Kotlin example demonstrates the experimental reactive API in InvUI. It creates an AnvilWindow with a click counter and a searchable item list. The UI elements automatically update based on `MutableProvider` values, eliminating manual refresh calls. It showcases `Item.Builder#setItemProvider`, `PagedGui#setContent`, and `AnvilWindow#addRenameHandler`.

```kotlin
val num: MutableProvider<Int> = mutableProvider(0) // stores the number of clicks on the '#' item
val query: MutableProvider<String> = mutableProvider("") // stores the anvil window text

fun example(player: Player) {
    // example item that shows click count
    Structure.addGlobalIngredient('#', Item.builder()
        .setItemProvider(num) { num -> ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setName("Count: $num") } // item updates based on num provider
        .addClickHandler { _, _ -> num.set(num.get() + 1) }) // click increments num

    // page buttons
    Structure.addGlobalIngredient('>', BoundItem.pagedGui()
        .setItemProvider { _, gui -> ItemBuilder(Material.ARROW).setName("Go to page ${gui.page + 2}/${gui.pageAmount}") }
        .addClickHandler { _, gui, click -> if (click.clickType == ClickType.LEFT) gui.page++ })
    Structure.addGlobalIngredient('<', BoundItem.pagedGui()
        .setItemProvider { _, gui -> ItemBuilder(Material.ARROW).setName("Go to page ${gui.page}/${gui.pageAmount}") }
        .addClickHandler { _, gui, click -> if (click.clickType == ClickType.LEFT) gui.page-- })
    
    // marker
    Structure.addGlobalIngredient('x', Markers.CONTENT_LIST_SLOT_HORIZONTAL)
    
    AnvilWindow.split()
        .setTitle("InvUI")
        .addRenameHandler(query) // automatically writes text into query provider
        .setUpperGui(
            Gui.builder()
                .setStructure("###")
                .addIngredient('#', Item.simple(ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setName(""))) // this item does nothing
        )
        .setLowerGui(PagedGui.items()
            .setStructure(
                "x x x x x x x x x",
                "x x x x x x x x x",
                "x x x x x x x x x",
                "# # < # # # > # #")
            .setContent(query) { query -> // content updates based on query provider
                Material.entries
                    .filter { !it.isLegacy && it.isItem && it.name.contains(query, true) }
                    .map { Item.simple(ItemStack(it)) }
            })
        .open(player)
}
```

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

### Example Nova Items Menu Category Configuration

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/configuration.md

Illustrates a practical `item_categories.yml` configuration. It includes two categories: one for machines with a rainbow-formatted name and another for various Minecraft dirt blocks, demonstrating how to group items and apply MiniMessage formatting.

```yaml
- icon: machines:quarry
  name: "<rainbow>Example Category Name</rainbow>" 
  items:
    - machines:quarry
    - machines:pulverizer
    - machines:electric_furnace
- icon: minecraft:dirt
  name: "Dirts"
  items:
    - minecraft:grass_block
    - minecraft:dirt
    - minecraft:dirt_path
    - minecraft:coarse_dirt
    - minecraft:rooted_dirt
```

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

### Kotlin Class Initialization with @Init Annotation

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/migration-guide/0.12-0.13.md

In version 0.13, classes can be automatically loaded during the initialization phase by annotating them with `@Init`. This is recommended for registry classes to ensure proper loading and simplify the initialization process.

```kotlin
@Init
```

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

### Kotlin Registry System Migration to ResourceLocation

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/migration-guide/0.12-0.13.md

The project has transitioned all 'registry-like' classes to Minecraft's built-in `Registry` system. This change deprecates `NamespacedId` in favor of Mojang's `ResourceLocation` and introduces builders for `NovaItem` and `NovaBlock` to streamline registration.

```kotlin
NamespacedId // deprecated
ResourceLocation // new
```

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

### Example: Whitelist Specific Language Files in Resource Pack

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/configuration.md

This YAML example demonstrates using a `whitelist` filter with `regex` to include only `en_us.json` and `de_de.json` language files, while excluding all others, from the `minecraft/lang/` directory during resource pack generation.

```yaml
- stage: resource_pack
  type: whitelist
  pattern_type: regex
  filter: minecraft\/lang\/(en_us|de_de).json
  directory: minecraft/lang/
```

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

### Example: Configure Attack Damage and Movement Speed Modifiers

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/configuration.md

This YAML example demonstrates how to apply `attribute_modifiers` to an item. It shows increasing attack damage by 5 when held in the main hand and boosting movement speed by 10% for both main and off-hand slots using `add_value` and `add_multiplied_base` operations, respectively.

```yaml
# The following configuration increases the player's attack damage by 5 if the item is held in the main hand
# and increases the movement speed by 10% for both the main hand and off hand.

attribute_modifiers:
  mainhand:
  - attribute: generic.attack_damage
    operation: add_value
    value: 5.0
  offhand:
  - attribute: generic.movement_speed
    operation: add_multiplied_base
    value: 0.1
  - attribute: generic.movement_speed
    operation: add_multiplied_base
    value: 0.1
```

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

### Configure Nova for Self-Hosted Resource Pack Upload

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/setup.md

This configuration enables Nova's automatic resource pack uploader to host the pack directly from your server. It starts a lightweight web server on the specified port, which must be open to the internet. Optionally, you can set a specific host IP address.

```yaml
resource_pack:
  auto_upload:
    enabled: true
    service: self_host
    port: 12345 # The port on which the web server will be running, needs to be open to the Internet.
```

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

### Migrating Nova Config Access

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/migration-guide/0.14-0.15.md

Nova now uses a fork of SpongePowered/Configurate, and the `configReloadable` mechanism has been deprecated. This snippet demonstrates the old and new syntax for accessing configuration entries for items and general namespaces.

```kotlin
val A: Long by configReloadble { NovaConfig[Items.EXAMPLE_ITEM].getLong("some.value") }
val B: Long by configReloadable { NovaConfig["namespace:name"].getLong("some.value") }
```

```kotlin
val A: Long by Items.EXAMPLE_ITEM.config.entry<Long>("some", "value")
val B: Long by Configs["namespace:name"].entry<Long>("some", "value")
```

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

### Create a Basic GUI with GuiBuilder in Kotlin and Java

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/guis/normal.md

This example demonstrates how to construct a simple graphical user interface using the GuiBuilder. It initializes a GUI with a predefined structure, using black stained glass panes as borders. The resulting GUI is a basic grid layout without interactive elements.

```Kotlin
val border = SimpleItem(ItemBuilder(Material.BLACK_STAINED_GLASS_PANE))
val gui = Gui.normal()
    .setStructure(
        "# # # # # # # # #",
        "# . . . . . . . #",
        "# . . . . . . . #",
        "# # # # # # # # #")
    .addIngredient('#', border)
    .build()
```

```Java
Item border = new SimpleItem(new ItemBuilder(Material.BLACK_STAINED_GLASS_PANE));
Gui gui = Gui.normal()
    .setStructure(
        "# # # # # # # # #",
        "# . . . . . . . #",
        "# . . . . . . . #",
        "# # # # # # # # #")
    .addIngredient('#', border)
    .build();
```

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

### Implementing DynamicRegion in a TileEntity with GUI

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/tile-entity/region.md

This comprehensive example demonstrates how to integrate a `DynamicRegion` into a `TileEntity`, allowing for a resizable region. It showcases the use of `storedRegion` to define region parameters and how to build a GUI with controls for increasing, decreasing, displaying, and visualizing the dynamic region's size.

```kotlin
class ExampleTileEntity(pos: BlockPos, blockState: NovaBlockState, data: Compound) : TileEntity(pos, blockState, data) {
    
    private val region = storedRegion(
        "region",
        minSize = provider(1), // (1)!
        maxSize = provider(10), // (2)!
        defaultSize = 5, // (3)!
        createRegion = { size -> Region.surrounding(pos, size) } // (4)!
    )
    
    @TileEntityMenuClass
    inner class ExampleTileEntityMenu(player: Player) : IndividualTileEntityMenu(player) {
        
        override val gui = Gui.builder()
            .setStructure(
                "v # # # # # # # #",
                "# # + # d # - # #",
                "# # # # # # # # #")
            .addIngredient('+', region.increaseSizeItem)
            .addIngredient('-', region.decreaseSizeItem)
            .addIngredient('d', region.displaySizeItem)
            .addIngredient('v', region.visualizeRegionItem)
            .build()
        
    }
    
}
```

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

### Example Usage of Minecraft Surface Relative Threshold Filter

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/placed-feature.md

These code examples demonstrate the practical application of the `minecraft:surface_relative_threshold_filter`. They show how to configure the filter using Kotlin and JSON, specifying the heightmap type and the inclusive minimum and maximum surface levels. This allows for precise control over terrain generation based on height.

```Kotlin
SurfaceRelativeThresholdFilter.of(
    Heightmap.Types.OCEAN_FLOOR_WG,
    Int.MIN_VALUE, // min
    -2 // max
)
```

```Json
{
  "type": "minecraft:surface_relative_threshold_filter",
  "heightmap": "OCEAN_FLOOR_WG",
  "max_inclusive": -2
}
```

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

### Add XenonDevs Maven Repository to Build Configuration

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/index.md

Before using the Nova API, you must add the XenonDevs Maven repository to your project's build configuration. This step allows your build system to locate and download Nova API artifacts.

```xml
<repository>
    <id>xenondevs</id>
    <url>https://repo.xenondevs.xyz/releases</url>
</repository>
```

```groovy
maven {
    url 'https://repo.xenondevs.xyz/releases'
}
```

```kotlin
maven("https://repo.xenondevs.xyz/releases")
```

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

### Configure End Gateway Feature in Kotlin and JSON

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/configurations/end-gateway.md

This snippet demonstrates how to configure an end gateway feature, specifically the vanilla return end gateway. It shows the setup in Kotlin using `EndGatewayConfiguration.knownExit` and its equivalent JSON representation, defining the exit point and exact teleportation behavior.

```Kotlin
@OptIn(ExperimentalWorldGen::class)
@Init(stage = InitStage.POST_PACK_PRE_WORLD)
object ConfiguredFeatures : FeatureRegistry by ExampleAddon.registry {

    val END_GATEWAY_RETURN = registerConfiguredFeature(
        "end_gateway_return",
        Feature.END_GATEWAY,
        EndGatewayConfiguration.knownExit(
            ServerLevel.END_SPAWN_POINT,
            true
        )
    )

}
```

```Json
{
  "type": "minecraft:end_gateway",
  "config": {
    "exact": true,
    "exit": [
      100,
      50,
      0
    ]
  }
}
```

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

### Add XenonDevs Maven Repository to Build Configuration

Source: https://github.com/xenondevs/docs/blob/main/docs/cbf/index.md

This snippet shows how to add the xenondevs Maven repository to your build configuration, which is required to access Cosmic Binary Format (CBF) artifacts. It provides examples for Maven, Gradle Groovy, and Gradle Kotlin.

```Maven
<repository>
    <id>xenondevs</id>
    <url>https://repo.xenondevs.xyz/releases</url>
</repository>
```

```Gradle Groovy
maven {
    url 'https://repo.xenondevs.xyz/releases'
}
```

```Gradle Kotlin
maven {
    url = uri("https://repo.xenondevs.xyz/releases")
}
```

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

### Obtain Nova API Instance in Kotlin and Java

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/index.md

To interact with the Nova API, you need to obtain its main instance. In Kotlin, the `Nova` object provides access, while in Java, you use the static `Nova.getNova()` method. This instance serves as the entry point for all Nova functionalities.

```kotlin
val nova = Nova // (1)!
```

```java
Nova nova = Nova.getNova();
```

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

### Add Cosmic Binary Format (CBF) Dependency to Build Configuration

Source: https://github.com/xenondevs/docs/blob/main/docs/cbf/index.md

This snippet demonstrates how to add the Cosmic Binary Format (CBF) library as a dependency to your project. It includes examples for Maven, Gradle Groovy, and Gradle Kotlin, allowing you to specify the desired version.

```Maven
<dependency>
    <groupId>xyz.xenondevs.cbf</groupId>
    <artifactId>cosmic-binary-format</artifactId>
    <version>VERSION</version>
</dependency>
```

```Gradle Groovy
implementation "xyz.xenondevs.cbf:cosmic-binary-format:VERSION"
```

```Gradle Kotlin
implementation("xyz.xenondevs.cbf:cosmic-binary-format:VERSION")
```

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

### Get Localized Name of a TileEntity

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/tileentity/tileentity.md

Illustrates how to obtain the localized name of a TileEntity, such as 'Pulverizer', by accessing its associated NovaBlock or material and specifying a locale (e.g., "en_us"). The example prints the retrieved name.

```Kotlin
val tileEntity = tileEntityManager.getTileEntityAt(location) ?: return
val name = tileEntity.block.getLocalizedName("en_us")
println(name) // prints "Pulverizer"
```

```Java
TileEntity tileEntity = tileEntityManager.getTileEntityAt(location);
if(tileEntity == null)
    return;
String name = tileEntity.getMaterial().getLocalizedName("en_us");
System.out.println(name); // prints "Pulverizer"
```

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

### Display an InvUI GUI to a Player using a Window

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/basics.md

Illustrates how to create a `Window` instance, associate it with a player and a previously built GUI, set a title, and then open it to display the inventory to the viewer.

```Kotlin
val window = Window.single()
    .setViewer(player)
    .setTitle("InvUI")
    .setGui(gui)
    .build()

window.open()
```

```Java
Window window = Window.single()
    .setViewer(player)
    .setTitle("InvUI")
    .setGui(gui)
    .build();

window.open();
```

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

### Configure Nova for Manual Resource Pack Hosting

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/setup.md

This configuration allows you to manually host the resource pack by uploading the 'ResourcePack.zip' file to a service of your choice. You then provide Nova with the direct download URL for the hosted pack. Note that the URL must be a direct link without redirects or visual elements.

```yaml
resource_pack:
  url: https://example.com/resource_pack.zip
```

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

### Registering a Nova Tile-Entity Block with Behaviors

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/tile-entity/introduction.md

This example illustrates how to register a `NovaBlock` for a custom Tile-Entity using the `@Init` annotation. It configures various behaviors like limits, drops, and interactivity, and sets the `handleTick` function's call rate.

```kotlin
@Init(stage = InitStage.PRE_PACK) // (1)!
object Blocks {
    
    val EXAMPLE_TILE_ENTITY = ExampleAddon.tileEntity("example_tile_entity", ::ExampleTileEntity) {
        behaviors(
            TileEntityLimited, // (2)!
            TileEntityDrops, // (3)!
            TileEntityInteractive // (4)!
        )
        tickrate(20) // (5)!
    }
    
}
```

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

### Add Nova API Dependency to Project

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/index.md

After configuring the repository, add the Nova API as a dependency to your project. This makes Nova's classes and methods available for use. Remember to replace 'VERSION' with the specific Nova API version you intend to use.

```xml
<dependency>
    <groupId>xyz.xenondevs.nova</groupId>
    <artifactId>nova-api</artifactId>
    <version>VERSION</version>
    <scope>provided</scope>
</dependency>
```

```groovy
implementation "xyz.xenondevs.nova:nova-api:VERSION"
```

```kotlin
implementation("xyz.xenondevs.nova:nova-api:VERSION")
```

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

### Defining a Basic Item Model

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/items/creating-items.md

This is the most basic model type, serving as a leaf in your model hierarchy. It directly links to a model file and allows defining tints. The example demonstrates setting `tintindex` 0 to read color from `minecraft:custom_model_data` and linking to `item/my_item`.

```kotlin
model = model {
    tintSource[0] = TintSource.CustomModelData(Color.WHITE, 0) // (1)!
    model = { getModel("item/my_item") } // (2)!
}
```

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

### Console Error for Missing Addons

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/setup.md

This console message indicates that an addon failed to initialize because one or more required addons are missing. The message specifies the name of the addon that failed and the names of the missing dependencies.

```Console
Failed to initialize <Name of the Addon>: Missing addon(s): <Name(s) of the required addon(s) that are missing>
```

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

### Utility Methods for Filling InvUI GUI Slots

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/guis/index.md

Provides examples of utility methods available in InvUI for programmatically filling GUI slots with items, other GUIs, or virtual inventories. Methods include filling the entire GUI, specific ranges, columns, rows, borders, or rectangular areas.

```Kotlin
gui.fill(item, replace) // fills everything
gui.fill(start, end, item, replace) // fills from the start index to the end index
gui.fillColumn(column, item, replace) // fills a column
gui.fillRow(row, item, replace) // fills a row
gui.fillBorders(item, replace) // fill the borders
gui.fillRectangle(x, y, width, height, item, replace) // fills a rectangle with an Item

gui.fillRectangle(x, y, gui, replace) // fills a rectangle with another GUI
gui.fillRectangle(x, y, width, virtualInventory, replace) // fills a rectangle with a VirtualInventory
```

```Java
gui.fill(item, replace); // fills everything
gui.fill(start, end, item, replace); // fills from the start index to the end index
gui.fillColumn(column, item, replace); // fills a column
gui.fillRow(row, item, replace); // fills a row
gui.fillBorders(item, replace); // fill the borders
gui.fillRectangle(x, y, width, height, item, replace); // fills a rectangle with an Item

gui.fillRectangle(x, y, gui, replace); // fills a rectangle with another GUI
gui.fillRectangle(x, y, width, virtualInventory, replace); // fills a rectangle with a VirtualInventory;
```

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

### Building a Window for a player and then opening it

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/windows.md

This approach allows for a two-step process: first, building a `Window` instance specifically for a player using `build(player)` on the `Window.Builder`, and then explicitly opening that built window. This provides more control over the window object before it's displayed.

```Kotlin
val window = Window.single()
    .setGui(gui)
    .setTitle("InvUI")
    .build(player)

window.open()
```

```Java
Window window = Window.single()
    .setGui(gui)
    .setTitle("InvUI")
    .build(player);

window.open();
```

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

### Configuring PackTask Dependencies

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/resourcepack/build-logic.md

This example illustrates how to define execution order dependencies for a `PackTask` using `runAfter` and `runBefore` parameters. Tasks are referenced by their simple class and function names (e.g., `CustomTaskHolder#customTask`), allowing fine-grained control over the build flow.

```kotlin
@PackTask(
    runAfter = ["LanguageContent#loadLangFiles", "EnchantmentContent#createBackgroundChars", "CharSizeCalculator#calculateCharSizes"],
    runBefore = ["LanguageContent#write"]
)
private fun write() {
    // ...
}
```

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

### Get Owner of a TileEntity

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/tileentity/tileentity.md

Demonstrates how to retrieve the owner of a TileEntity instance using its manager. It first attempts to get the TileEntity at a specific location and then accesses its owner property.

```Kotlin
val tileEntity = tileEntityManager.getTileEntityAt(location) ?: return
val owner = tileEntity.owner
```

```Java
TileEntity tileEntity = tileEntityManager.getTileEntityAt(location);
if (tileEntity == null)
    return;
OfflinePlayer owner = tileEntity.getOwner();
```

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

### Create and Manipulate an InvUI GUI Programmatically

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/basics.md

Shows alternative methods for creating and populating a GUI without using the `GuiBuilder`. It demonstrates creating an empty GUI, setting items by coordinates or slot index, and applying a `Structure` directly.

```Kotlin
// create the GUI
val gui = Gui.empty(9, 4)

// set items using x and y coordinates
gui.setItem(0, 0, item)

// set an item using the slot index
gui.setItem(10, item)

// use a Structure to add items (like in the GuiBuilder)
val structure: Structure = Structure(
    "# # # # # # # # #",
    "# . . . . . . . #",
    "# . . . . . . . #",
    "# # # # # # # # #")
    .addIngredient('#', item)

gui.applyStructure(structure)
```

```Java
// create the GUI
Gui gui = Gui.empty(9, 4);

// set items using x and y coordinates
gui.setItem(0, 0, item);

// set an item using the slot index
gui.setItem(10, item);

// use a Structure to add items (like in the GuiBuilder)
Structure structure = new Structure(
    "# # # # # # # # #",
    "# . . . . . . . #",
    "# . . . . . . . #",
    "# # # # # # # # #")
    .addIngredient('#', item);

gui.applyStructure(structure);
```

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

### Create a Default GUI using GuiBuilder in InvUI

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/basics.md

Demonstrates how to construct a basic GUI using InvUI's `Gui.Builder` pattern. It sets a predefined structure with black stained glass panes and empty slots, providing a visual layout for the inventory.

```Kotlin
val gui = Gui.normal() // Creates the GuiBuilder for a normal GUI
    .setStructure(
        "# # # # # # # # #",
        "# . . . . . . . #",
        "# . . . . . . . #",
        "# # # # # # # # #")
    .addIngredient('#', SimpleItem(ItemBuilder(Material.BLACK_STAINED_GLASS_PANE)))
    .build()
```

```Java
Gui gui = Gui.normal() // Creates the GuiBuilder for a normal GUI
    .setStructure(
        "# # # # # # # # #",
        "# . . . . . . . #",
        "# . . . . . . . #",
        "# # # # # # # # #")
    .addIngredient('#', new SimpleItem(new ItemBuilder(Material.BLACK_STAINED_GLASS_PANE)))
    .build();
```

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

### Creating and opening a Window directly from Builder

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/windows.md

This method provides a convenient shortcut to both construct a new `Window` and immediately display it to a specified player. By calling `open(player)` directly on the `Window.Builder`, the window is built and shown in one step.

```Kotlin
Window.single()
    .setGui(gui)
    .setTitle("InvUI")
    .open(player)
```

```Java
Window.single()
    .setGui(gui)
    .setTitle("InvUI")
    .open(player);
```

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

### Registering a Simple Item

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/items/creating-items.md

You can register a basic item by calling `ExampleAddon.registerItem` within your `Items` singleton. This item will default to a model under `models/item/example_item.json` or create a basic model with the texture `textures/item/example_item.png`.

```kotlin
@Init(stage = InitStage.PRE_PACK)
object Items {

   val EXAMPLE_ITEM = ExampleAddon.registerItem("example_item", /* Item Behaviors */)
   
}
```

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

### Applying Registered Equipment to Items in Nova (Kotlin)

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/items/equipment.md

This Kotlin example shows how to apply previously registered custom equipment to an in-game item. By using the 'Equippable' behavior with the equipment instance and an 'EquipmentSlot', the item becomes wearable in the specified slot.

```kotlin
val EXAMPLE_HELMET = registerItem("example_helmet", Equippable(Armor.EXAMPLE, EquipmentSlot.HEAD))
```

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

### Create InvUI Windows using Builders (Kotlin/Java)

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/windows.md

This snippet demonstrates how to instantiate different types of InvUI windows, such as Window.single() and AnvilWindow.split(), using their respective builder patterns. It shows how to set the viewer, assign GUIs (upper and lower for split windows), set a title, and add rename handlers for Anvil windows. The examples cover both Kotlin and Java syntax.

```Kotlin
val normalWindow = Window.single()
    .setViewer(player)
    .setGui(gui)
    .setTitle("InvUI")
    .build()

val anvilWindow = AnvilWindow.split()
    .setViewer(player)
    .setUpperGui(anvilGui)
    .setLowerGui(playerGui)
    .setTitle("InvUI")
    .addRenameHandler { println(it) }
    .build()
```

```Java
Window window = Window.single()
    .setViewer(player)
    .setGui(gui)
    .setTitle("InvUI")
    .build();

AnvilWindow window = AnvilWindow.split()
    .setViewer(player)
    .setUpperGui(anvilGui)
    .setLowerGui(playerGui)
    .setTitle("InvUI")
    .addRenameHandler(s -> System.out.println(s))
    .build();
```

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

### Access Provider Values with get() Method

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/migration-guide/0.16-0.17.md

Providers now require calling get() to access their value instead of using the .value property. Additionally, providers are now lazy, loading or updating their value only upon access.

```APIDOC
Provider<T>:
  // Previously: provider.value
  // Now:
  get(): T
```

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

### Example Configuration and Placement of Hay Bale Piles

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/configurations/block-pile.md

Illustrates how to configure and place a `block_pile` feature for hay bales in villages using both Kotlin and JSON. It shows how to register configured and placed features, including the use of `RotatedBlockProvider` for random rotation and the self-resolving nature of the feature's placement.

```Kotlin
@OptIn(ExperimentalWorldGen::class)
@Init(stage = InitStage.POST_PACK_PRE_WORLD)
object ConfiguredFeatures : FeatureRegistry by ExampleAddon.registry {

    val PILE_HAY = registerConfiguredFeature(
        "pile_hay",
        Feature.BLOCK_PILE,
        BlockPileConfiguration(RotatedBlockProvider(Blocks.HAY_BLOCK)) // (1)!
    )

}
```

```Kotlin
@OptIn(ExperimentalWorldGen::class)
@Init(stage = InitStage.POST_PACK_PRE_WORLD)
object PlacedFeatures: FeatureRegistry by ExampleAddon.registry {

    val PILE_HAY = placedFeature("pile_hay", ConfiguredFeatures.PILE_HAY).register() // (1)!

}
```

```Json
{
  "type": "minecraft:block_pile",
  "config": {
    "state_provider": {
      "type": "minecraft:rotated_block_provider",
      "state": {
        "Name": "minecraft:hay_block",
        "Properties": {
          "axis": "y" // (1)!
        }
      }
    }
  }
}
```

```Json
{
  "feature": "minecraft:pile_hay",
  "placement": [] // (1)!
}
```

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

### ReferencingInventory and Bukkit Integration

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/inventory.md

Explains `ReferencingInventory` as an adapter for Bukkit inventories, highlighting the need for manual window updates when changes occur directly in the underlying Bukkit inventory.

```APIDOC
xyz.xenondevs.invui.inventory.ReferencingInventory:
  Description: An Inventory backed by a Bukkit inventory, reflecting changes between both.
  Behavior:
    - Changes via InvUI methods notify displaying Windows.
    - Changes directly in the Bukkit inventory DO NOT notify displaying Windows.
  Usage Note:
    - Call Inventory#notifyWindows() manually when changes are made directly in the Bukkit inventory to update displaying GUIs.
```

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

### Example Usage of Minecraft Surface Water Depth Filter

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/placed-feature.md

These code examples illustrate how to implement the `minecraft:surface_water_depth_filter`. They provide both Kotlin and JSON syntax for setting the `max_water_depth` parameter. This filter is crucial for controlling the presence of water bodies during world generation.

```Kotlin
SurfaceWaterDepthFilter.forMaxDepth(2)
```

```Json
{
  "type": "minecraft:surface_water_depth_filter",
  "max_water_depth": 2
}
```

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

### Get NovaItem by Namespaced ID

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/items/index.md

This snippet shows how to retrieve a specific `NovaItem` using its fully qualified namespaced ID (e.g., `namespace:name`). It uses the `NovaItemRegistry` obtained previously. Be aware that `get()` throws an exception if the item is not found; consider `getOrNull()` for user input.

```Kotlin
val item = itemRegistry.get("nova:wrench")
```

```Java
NovaItem item = itemRegistry.get("nova:wrench");
```

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

### Opening an existing Window instance

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/windows.md

This snippet demonstrates the fundamental way to display an already created `Window` instance to a player by invoking its `open()` method. This assumes the `window` object has been previously initialized.

```Kotlin
window.open()
```

```Java
window.open();
```

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

### Construct a Tab GUI with Multiple Tabs and Structure

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/guis/tab.md

This snippet shows how to instantiate and configure a `TabGui` in Kotlin and Java. It sets up a visual structure using a grid, adds ingredients for borders and custom tab items, and associates content GUIs (e.g., `gui1` and `gui2`) with each tab. This example creates a GUI with two tabs, demonstrating how to define the layout and content.

```Kotlin
val border = SimpleItem(ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setDisplayName(""))
    
val gui1 = Guis.empty(9, 3)
gui1.fill(SimpleItem(ItemBuilder(Material.DIRT)), true)
    
val gui2 = Guis.empty(9, 3)
gui2.fill(SimpleItem(ItemBuilder(Material.DIAMOND)), true)
    
val gui = TabGui.normal()
    .setStructure(
        "# # # 0 # 1 # # #",
        "x x x x x x x x x",
        "x x x x x x x x x",
        "x x x x x x x x x")
    .addIngredient('x', Markers.CONTENT_LIST_SLOT_HORIZONTAL)
    .addIngredient('#', border)
    .addIngredient('0', MyTabItem(0))
    .addIngredient('1', MyTabItem(1))
    .setTabs(listOf(gui1, gui2))
    .build()
```

```Java
Item border = new SimpleItem(new ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setDisplayName(""));
    
Gui gui1 = Guis.empty(9, 3);
gui1.fill(new SimpleItem(new ItemBuilder(Material.DIRT)), true);
    
Gui gui2 = Guis.empty(9, 3);
gui2.fill(new SimpleItem(new ItemBuilder(Material.DIAMOND)), true);
    
Gui gui = TabGui.normal()
    .setStructure(
        "# # # 0 # 1 # # #",
        "x x x x x x x x x",
        "x x x x x x x x x",
        "x x x x x x x x x")
    .addIngredient('x', Markers.CONTENT_LIST_SLOT_HORIZONTAL)
    .addIngredient('#', border)
    .addIngredient('0', new MyTabItem(0))
    .addIngredient('1', new MyTabItem(1))
    .setTabs(Arrays.asList(gui1, gui2))
    .build();
```

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

### Place Configured Seagrass Feature in World

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/configurations/seagrass.md

This snippet illustrates how to place the previously configured seagrass feature within the game world, applying various placement modifiers. These modifiers include horizontal spreading, setting the y-coordinate to the ocean floor, defining the count per chunk, and filtering by biome. The Kotlin example uses method chaining, while the JSON example uses an array of placement objects.

```Kotlin
@OptIn(ExperimentalWorldGen::class)
@Init(stage = InitStage.POST_PACK_PRE_WORLD)
object PlacedFeatures : FeatureRegistry by ExampleAddon.registry {
    
    val SEAGRASS_TALL = placedFeature("seagrass_tall", ConfiguredFeatures.SEAGRASS_TALL)
        .inSquareSpread() // (1)!
        .moveToTopSolid() // (2)!
        .count(80) // (3)!
        .biomeFilter() // (4)!
        .register()
    
}
```

```JSON
{
  "feature": "minecraft:seagrass_tall",
  "placement": [
    {
      "type": "minecraft:in_square" // (1)!
    },
    {
      "type": "minecraft:heightmap",
      "heightmap": "OCEAN_FLOOR_WG" // (2)!
    },
    {
      "type": "minecraft:count", // (3)!
      "count": 80
    },
    {
      "type": "minecraft:biome" // (4)!
    }
  ]
}
```

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

### Place Sea Pickle Feature with Filters (Rarity, Spread, Heightmap, Biome)

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/configurations/sea-pickle.md

This snippet illustrates how to place the configured `sea_pickle` feature in the world, applying several placement filters. It includes filters for rarity (place in every 16th chunk), in-square spread (random horizontal offset), heightmap (set y-coordinate to the ocean floor), and biome (only place in warm ocean biome). The Kotlin example uses method chaining, while the JSON example uses an array of placement objects.

```Kotlin
@OptIn(ExperimentalWorldGen::class)
@Init(stage = InitStage.POST_PACK_PRE_WORLD)
object PlacedFeatures : FeatureRegistry by ExampleAddon.registry {

    val SEA_PICKLE = placedFeature("sea_pickle", ConfiguredFeatures.SEA_PICKLE)
        .rarityFilter(16) // Place sea pickles in every 16th chunk.
        .inSquareSpread() // Randomly offset the placement horizontally.
        .moveToTopSolid() // Set y-coordinate to the ocean floor. This call is equivalent to HeightmapPlacement.onHeightmap(Heightmap.Types.OCEAN_FLOOR_WG)
        .biomeFilter() // Only place in the warm ocean biome.
        .register()

}
```

```Json
{
  "feature": "minecraft:sea_pickle",
  "placement": [
    {
      "type": "minecraft:rarity_filter",
      "chance": 16
    },
    {
      "type": "minecraft:in_square"
    },
    {
      "type": "minecraft:heightmap",
      "heightmap": "OCEAN_FLOOR_WG"
    },
    {
      "type": "minecraft:biome"
    }
  ]
}
```

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

### Retrieve a block type by its ID

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/blocks/blockregistry.md

Demonstrates how to use the BlockRegistry to fetch a specific block type using its unique string identifier, for example, 'machines:pulverizer'.

```Kotlin
val block = blockRegistry.getBlock("machines:pulverizer")
```

```Java
NovaBlock block = blockRegistry.getBlock("machines:pulverizer");
```

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

### VirtualInventory Creation, Stack Sizes, and Serialization

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/inventory.md

Details the creation methods for `VirtualInventory`, how to customize stack sizes, and the mechanisms for serialization and deserialization, including integration with `VirtualInventoryManager`.

```APIDOC
xyz.xenondevs.invui.inventory.VirtualInventory:
  Description: A virtual inventory that can store a predefined amount of ItemStacks without a defined width or height.
  Creation:
    - Constructor: VirtualInventory(int size, ...)
    - Deserialization: VirtualInventory#deserialize(InputStream stream)
    - Deserialization: VirtualInventory#deserialize(byte[] data)
    - Manager: VirtualInventoryManager#getOrCreate(...)
  Custom Stack Sizes:
    - Constructor Parameter: maxStackSizes (int[])
    - Method: setMaxStackSizes(int[] maxStackSizes)
    - Method: setMaxStackSize(int slot, int maxStackSize)
    - Global Provider: InventoryUtils#stackSizeProvider (to set a custom StackSizeProvider)
  Serialization:
    - Method: serialize() (returns byte[] or writes to OutputStream)
    - Method: deserialize(InputStream stream)
    - Method: deserialize(byte[] data)
    - Manager Integration: VirtualInventoryManager (for automatic serialization/deserialization)
      - uuid parameter: Required for serialization with VirtualInventoryManager.
      - Serialized content: Only UUID and ItemStack[] are serialized.
```

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

### Get TileEntity at Specific Location

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/tileentity/tileentitymanager.md

This snippet demonstrates how to retrieve a `TileEntity` at a specified `location` using the `getTileEntityAt` function of `TileEntityManager`. The function returns the `TileEntity` if found, or `null` otherwise.

```kotlin
val tileEntity: TileEntity? = tileEntityManager.getTileEntityAt(location)
```

```java
TileEntity tileEntity = tileEntityManager.getTileEntityAt(location);
```

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

### Nova Plugin Base Resource Pack Configuration

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/setup.md

This YAML snippet shows how to configure Nova to merge with an existing resource pack. The `base_packs` array under `resource_pack.generation` specifies paths to resource pack directories or zip files, such as `plugins/ItemsAdder/output/generated.zip`. Nova uses these paths to analyze and adjust its own resource pack data, ensuring compatibility and preventing conflicts.

```YAML
resource_pack:
  generation:
    base_packs:
      - plugins/ItemsAdder/output/generated.zip
```

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

### Define Codec for ResourceLocation Field

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/codec.md

This snippet shows how to define a codec for the 'id' field of the Example data class, reusing an existing ResourceLocation codec and specifying the field name and getter.

```Kotlin
ResourceLocation.CODEC
    .fieldOf("id")
    .forGetter(Example::id)
```

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

### Define Kotlin Data Class for Codec Example

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/codec.md

This data class serves as the target for custom codec definition, demonstrating a type with a ResourceLocation, a list of integers, and an optional string field.

```Kotlin
data class Example(
    val id: ResourceLocation,
    val ints: List<Int>,
    val defaultString: String
)
```

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

### Get Drops from a TileEntity

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/api/tileentity/tileentity.md

Shows how to retrieve all items dropped by a TileEntity. These drops include all items in the TileEntity's inventory and can optionally include the TileEntity itself if 'includeSelf' is set to true.

```Kotlin
val tileEntity = tileEntityManager.getTileEntityAt(location) ?: return
val drops = tileEntity.getDrops(includeSelf = true)
```

```Java
TileEntity tileEntity = tileEntityManager.getTileEntityAt(location);
if (tileEntity == null)
    return;
List<ItemStack> drops = tileEntity.getDrops(true);
```

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

### Create and Apply GUI Structures with Ingredients (Kotlin/Java)

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/structure.md

This snippet demonstrates how to define a GUI layout using a `Structure` object, associating characters with specific GUI elements like content slots, decorative items, and navigation controls. It shows how to apply the created structure to a `PagedGui` builder or an existing GUI instance.

```Kotlin
// create a structure
val structure = Structure(
    "# # # # # # # # #",
    "# x x x x x x x #",
    "# x x x x x x x #",
    "# # # < # > # # #")
    .addIngredient('x', Markers.CONTENT_LIST_SLOT_HORIZONTAL) // where paged items should be put
    .addIngredient('#', ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setDisplayName("")) // this will just create a SimpleItem with the given ItemBuilder
    .addIngredient('<', BackItem())
    .addIngredient('>', ForwardItem())

// use it in a GUI Builder
PagedGui.items().setStructure(structure)

// or use it on an existing GUI
gui.applyStructure(structure)
```

```Java
// create a structure
Structure structure = new Structure(
    "# # # # # # # # #",
    "# x x x x x x x #",
    "# x x x x x x x #",
    "# # # < # > # # #")
    .addIngredient('x', Markers.CONTENT_LIST_SLOT_HORIZONTAL) // where paged items should be put
    .addIngredient('#', new ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setDisplayName("")) // this will just create a SimpleItem with the given ItemBuilder
    .addIngredient('<', new BackItem())
    .addIngredient('>', new ForwardItem());

// use it in a GUI Builder
PagedGui.items().setStructure(structure);

// or use it on an existing GUI
gui.applyStructure(structure);
```

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

### Construct Paged GUI with Navigation and Content (Kotlin/Java)

Source: https://github.com/xenondevs/docs/blob/main/docs/invui/guis/paged.md

This code demonstrates how to assemble a `PagedGui` to display a list of items. It defines a border item, prepares a list of `SimpleItem`s from all available materials, and then uses a structure string to lay out the GUI. It integrates the previously defined `BackItem` and `ForwardItem` for navigation and specifies where the paged content should appear.

```Kotlin
val border = SimpleItem(ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setDisplayName(""))
    
// an example list of items to display
val items = Material.values()
    .filter { !it.isAir && it.isItem }
    .map { SimpleItem(ItemBuilder(it)) }

// create the gui
val gui = PagedGui.items()
    .setStructure(
        "# # # # # # # # #",
        "# x x x x x x x #",
        "# x x x x x x x #",
        "# # # < # > # # #")
    .addIngredient('x', Markers.CONTENT_LIST_SLOT_HORIZONTAL) // where paged items should be put
    .addIngredient('#', border)
    .addIngredient('<', BackItem())
    .addIngredient('>', ForwardItem())
    .setContent(items)
    .build()
```

```Java
Item border = new SimpleItem(new ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setDisplayName(""));
    
// an example list of items to display
List<Item> items = Arrays.stream(Material.values())
    .filter(material -> !material.isAir() && material.isItem())
    .map(material -> new SimpleItem(new ItemBuilder(material)))
    .collect(Collectors.toList());

// create the gui
Gui gui = PagedGui.items()
    .setStructure(
        "# # # # # # # # #",
        "# x x x x x x x #",
        "# x x x x x x x #",
        "# # # < # > # # #")
    .addIngredient('x', Markers.CONTENT_LIST_SLOT_HORIZONTAL) // where paged items should be put
    .addIngredient('#', border)
    .addIngredient('<', new BackItem())
    .addIngredient('>', new ForwardItem())
    .setContent(items)
    .build();
```

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

### Nova Tile-Entity Limit by World Configuration

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/configuration.md

Configures Nova to prevent players from placing any tile-entities in specified worlds. This example restricts tile-entity placement in 'world_nether' and 'world_the_end' by listing them under `performance.tile_entity_limits.world`.

```yaml
# This example config prevents players from placing tile-entities in the nether and end dimension.
performance:
  tile_entity_limits:
    world:
      - world_nether
      - world_the_end
```

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

### Manage Initialization Dependencies with runAfter and runBefore

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/initialization.md

Configure explicit initialization dependencies using `runAfter` and `runBefore` parameters within the `@Init` annotation. This ensures a class is initialized only after specified classes or before others, providing fine-grained control over the initialization order.

```kotlin
@Init(
    stage = InitStage.PRE_PACK,
    runAfter = [ClassA::class], // This class will be initialized after ClassA
    runBefore = [ClassB::class] // This class will be initialized before ClassB
)
object Example
```

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

### Nova Tile-Entity Limit by Type Configuration

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/admin/configuration.md

Configures Nova to prevent players from placing specific tile-entities. This example restricts the placement of the 'machines:quarry' by listing it under `performance.tile_entity_limits.type` in the configuration file.

```yaml
# This example config prevents players from placing the quarry.
performance:
  tile_entity_limits:
    type:
      - machines:quarry
```

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

### Minecraft: Random Offset Placement Definition and Usage

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/placed-feature.md

Offsets a given position by values provided by `IntProvider`s for XZ and Y coordinates. Includes API parameters and usage examples in Kotlin and JSON.

```APIDOC
xz_spread: IntProvider
  Description: An IntProvider. (Range limit in Json is [-16;16]). x and z are sampled separately!
y_spread: IntProvider
  Description: An IntProvider. (Range limit in Json is [-16;16]).
```

```Kotlin
RandomOffsetPlacement.of(ConstantInt.ZERO, UniformInt.of(3, 9))
```

```JSON
{
  "type": "minecraft:random_offset",
  "xz_spread": 0,
  "y_spread": {
    "type": "minecraft:uniform",
    "value": {
      "max_inclusive": 9,
      "min_inclusive": 3
    }
  }
}
```

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

### Kotlin Example: Implementing Side Configuration GUI for Tile Entity

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/tile-entity-networks/networked-tile-entity.md

This Kotlin code demonstrates how to create a `NetworkedTileEntity` that integrates `SideConfigMenu` to manage side configurations for energy, item, and fluid networks. It defines various data holders (energy, input/output inventories, fluid container) and constructs a `Gui` with an `OpenSideConfigItem` to access the side configuration menu, along with inventory slots.

```kotlin
class ExampleTileEntity(pos: BlockPos, blockState: NovaBlockState, data: Compound) : NetworkedTileEntity(pos, blockState, data) {
    
    // end point data holders from the previous examples
    private val energyHolder = storedEnergyHolder(provider(1000L), NetworkConnectionType.BUFFER)
    private val inputInventory = storedInventory("input", 9)
    private val outputInventory = storedInventory("output", 9)
    private val itemHolder = storedItemHolder(inputInventory to NetworkConnectionType.INSERT, outputInventory to NetworkConnectionType.EXTRACT)
    private val fluidContainer = storedFluidContainer("fluidContainer", setOf(FluidType.WATER), provider(10_000L))
    private val fluidHolder = storedFluidHolder(fluidContainer to NetworkConnectionType.EXTRACT)
    
    @TileEntityMenuClass
    inner class ExampleTileEntityMenu : GlobalTileEntityMenu() {
        
        private val sideConfigMenu = SideConfigMenu(
            endPoint = this@ExampleTileEntity,
            // localization keys for inventories
            inventories = mapOf(
                itemHolder.getNetworkedInventory(inputInventory) to "inventory.example_addon.input",
                itemHolder.getNetworkedInventory(outputInventory) to "inventory.example_addon.output"
            ),
            // localization keys for fluid contains
            containers = mapOf(fluidContainer to "container.example_addon.fluid_tank"),
            openPrevious = ::openWindow
        )
        
        override val gui = Gui.builder()
            .setStructure(
                "s # # # # # # # #",
                "# i i i # o o o #",
                "# i i i # o o o #",
                "# i i i # o o o #",
                "# # # # # # # # #")
            .addIngredient('s', OpenSideConfigItem(sideConfigMenu))
            .addIngredient('i', inputInventory)
            .addIngredient('o', outputInventory)
            .build()
    
    }
    
}
```

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

### Minecraft: Rarity Filter Placement Definition and Usage

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/placed-feature.md

Filters a position, returning it or empty based on a chance calculated as `1 / chance`. Includes API parameters and usage examples in Kotlin and JSON.

```APIDOC
chance: int
  Description: A positive int that determines the average amount of tries between a success.
```

```Kotlin
RarityFilter.onAverageOnceEvery(9)
```

```JSON
{
  "type": "minecraft:rarity_filter",
  "chance": 9
}
```

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

### Configuring Nether Sprouts Vegetation Feature

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/configurations/nether-forest-vegetation.md

Example of how to configure the `nether_forest_vegetation` feature to spread nether sprouts. This involves specifying the block state provider and the dimensions for spreading the vegetation.

```Kotlin
@OptIn(ExperimentalWorldGen::class)
@Init(stage = InitStage.POST_PACK_PRE_WORLD)
object ConfiguredFeatures : FeatureRegistry by ExampleAddon.registry {

    val NETHER_SPROUTS = registerConfiguredFeature(
        "nether_sprouts",
        Feature.NETHER_FOREST_VEGETATION,
        NetherForestVegetationConfig(
            BlockStateProvider.simple(Blocks.NETHER_SPROUTS), // block used for the vegetation
            8, // spreadWidth
            4 // spreadHeight
        )
    )

}
```

```Json
{
  "type": "minecraft:nether_forest_vegetation",
  "config": {
    "state_provider": {
      "type": "minecraft:simple_state_provider",
      "state": {
        "Name": "minecraft:nether_sprouts"
      }
    },
    "spread_height": 4,
    "spread_width": 8
  }
}
```

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

### Minecraft: Noise Threshold Count Logic and Usage

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/worldgen/features/placed-feature.md

Defines how a position is returned multiple times based on a noise value and threshold. Includes the core logic, API parameters, and examples in Kotlin and JSON.

```Java
if (noise < threshold) {
  return below_noise;
} else { // noise >= threshold
  return above_noise;
}
```

```APIDOC
noise_level: double
  Description: A double value of the threshold that determines whether the position is returned below_noise or above_noise times.
below_noise: int
  Description: An int that determines how often the position is returned if the noise value is below the threshold.
above_noise: int
  Description: An int that determines how often the position is returned if the noise value is above/equal to the threshold.
```

```Kotlin
NoiseThresholdCountPlacement.of(
    -0.8, // Noise level
    5, // Below noise
    10 // Above noise
)
```

```JSON
{
  "type": "minecraft:noise_threshold_count",
  "noise_level": -0.8,
  "above_noise": 10,
  "below_noise": 5
}
```

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

### Example Minecraft Resource Pack Language File Structure

Source: https://github.com/xenondevs/docs/blob/main/docs/nova/addon/resourcepack/addon-assets.md

This JSON snippet demonstrates the recommended key format for language files within a Minecraft resource pack, specifically for Nova projects. Keys follow the `[<type>].<namespace/addon-id>.<item>` pattern, allowing for categorization of translations for items, blocks, advancements, and more. It ensures proper localization of custom content.

```JSON
{
  "item.example_addon.ruby": "Ruby",
  "block.example_addon.solar_panel": "Solar Panel",
  "advancement.example_addon.ruby.title": "Ruby",
  "advancement.example_addon.ruby.description": "Acquire a ruby",
  "advancement.example_addon.solar_panel.title": "Clean Energy",
  "advancement.example_addon.solar_panel.description": "Craft a Solar Panel"
}
```
Tokens:
Raw