Kore

https://kore.ayfri.com/
Admin
Kore is a modern, open-source Kotlin library for Minecraft datapack development that eliminates the...
Tokens:222,242
Snippets:2,431
Trust Score:7.5
Update:1 month ago
Show doc for...
Tokens:
Raw
### Complete Test Suite Example

Source: https://kore.ayfri.com/docs/advanced/test-features

A comprehensive example demonstrating environment creation, setup/teardown functions, and multiple test instance configurations.

```Kotlin
fun DataPack.createTestSuite() {
	val setupFn = function("test_setup") { say("Setting up test") }
	val cleanupFn = function("test_cleanup") { say("Cleaning up test") }
	// Create reusable environments
	val controlled = testEnvironmentsBuilder.gameRules("controlled") {
		this[Gamerules.DO_DAYLIGHT_CYCLE] = false
		this[Gamerules.DO_MOB_SPAWNING] = false
		this[Gamerules.RANDOM_TICK_SPEED] = 0
	}
  val dayTime = testEnvironmentsBuilder.clockTime("day", WorldClocks.OVERWORLD, 6000)
	val controlledDay = testEnvironmentsBuilder.allOf("controlled_day", controlled, dayTime)

	// Function environment (setup/teardown)
	testEnvironments {
		function("test_functions") {
			setup(setupFn)
			teardown(cleanupFn)
		}
    }

    testInstances {
        testInstance("redstone_basic") {
            blockBased()
	        environment(controlledDay)
            maxTicks = 100
            required = true
            structure(Structures.AncientCity.Structures.BARRACKS)
        }

        testInstance("complex_logic_test") {
            functionBased()
	        environment(controlled)
	        function("com.example.MyMod::myTest")
            maxAttempts = 2
            maxTicks = 200
            required = true
            structure(Structures.AncientCity.Structures.BARRACKS)
        }

        testInstance("directional_blocks") {
            blockBased()
            clockwise90()
	        environment(controlled)
            maxTicks = 120
            required = true
            structure(Structures.AncientCity.Structures.BARRACKS)
        }
    }
}
```

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

### Complete World Clock Integration Example

Source: https://kore.ayfri.com/docs/data-driven/world-clocks

A comprehensive example demonstrating custom clock registration, timeline creation, dimension configuration, predicates, and time-based commands.

```Kotlin
dataPack("my_mod") {
	// 1. Register a custom clock
	val season = worldClock("season")

	// 2. Build a timeline driven by that clock
	timeline("seasons", clock = season) {
		periodTicks = 96000

		timeMarker("spring", ticks = 0, showInCommands = true)
		timeMarker("summer", ticks = 24000, showInCommands = true)
		timeMarker("autumn", ticks = 48000, showInCommands = true)
		timeMarker("winter", ticks = 72000, showInCommands = true)

		track(EnvironmentAttributes.Visual.FOG_END_DISTANCE) {
			ease = InOutSine
			keyframe(0) { value(200.0f) }
			keyframe(24000) { value(300.0f) }
			keyframe(48000) { value(200.0f) }
			keyframe(72000) { value(80.0f) }
		}
	}

	// 3. Wire the clock to a custom dimension
	val dimType = dimensionType("my_dimension_type") {
		defaultClock = season
		natural = true
		hasSkylight = true
		logicalHeight = 256
		infiniburn = Tags.Block.INFINIBURN_OVERWORLD
		minY = -64
		height = 384
		monsterSpawnBlockLightLimit = 0
		monsterSpawnLightLevel = constant(0)
	}

	// 4. Predicate: is it currently summer?
	predicate("is_summer") {
		timeCheck(season, min = 24000f, max = 48000f)
	}

	// 5. Command: skip to winter
	function("skip_to_winter") {
		time.of(season).set(timeMarker("winter", "my_mod"))
	}

	// 6. Command: advance the season clock
	function("tick_season") {
		time.of(season).add(1)
		time.of(season).query(TimeType.DAYTIME)
	}
}
```

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

### Minimal Datapack Example

Source: https://kore.ayfri.com/docs/home

A basic example showing how to define a datapack with a single function that sends a 'Hello World!' message to all players, then generates it as a zip file.

```kotlin
fun main() {
	val datapack = dataPack("example") {
		function("display_text") {
			tellraw(allPlayers(), textComponent("Hello World!"))
		}
	}

	datapack.generateZip()
}
```

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

### Float Provider Configuration Examples

Source: https://kore.ayfri.com/docs/data-driven/worldgen/providers

Examples of various float provider builders used to define configuration fields.

```kotlin
yScale = constant(1.5f)
pitch = uniform(0.8f, 1.2f)
floorLevel = clampedNormal(mean = 0.5f, deviation = 0.2f, min = 0.0f, max = 1.0f)
thickness = trapezoid(min = 0.0f, max = 2.0f, plateau = 0.5f)
```

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

### Arena intro effect example

Source: https://kore.ayfri.com/docs/helpers/vfx-particles

A practical example of creating a spiral effect for arena intros or spawn platforms.

```Kotlin
drawShape("arena_intro") {
	shape = Shape.SPIRAL
	particle = Particles.HAPPY_VILLAGER
	radius = 4.0
	points = 60
	height = 6.0
	turns = 5
}
```

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

### Stopwatch Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Shows how to manage server-side timers that persist across sessions.

```Kotlin
function("stopwatch_examples") {
	val myStopwatch = stopWatch("my_timer")
	stopwatchCreate(myStopwatch)
	stopwatchQuery(myStopwatch)
	stopwatchRestart(myStopwatch)
	stopwatchRemove(myStopwatch)
}
```

```Mcfunction
stopwatch my_datapack:my_timer create
stopwatch my_datapack:my_timer query
stopwatch my_datapack:my_timer restart
stopwatch my_datapack:my_timer remove
```

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

### Particle Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates basic particle spawning and the use of force mode and entity selectors.

```Kotlin
function("particle_examples") {
	particle(Particles.ASH)

	// arguments are position, delta (how far particles scatter), speed, then count
	particle(Particles.ASH, vec3(), vec3(), 1.0, 2)

	// force shows the particle even far away or through blocks
	particle(Particles.ASH, vec3(), vec3(), 1.0, 2, ParticleMode.FORCE)

	// a last selector limits who sees the particle
	particle(Particles.ASH, vec3(), vec3(), 1.0, 2, ParticleMode.NORMAL, allEntities())
}
```

```Mcfunction
particle minecraft:ash
particle minecraft:ash ~ ~ ~ ~ ~ ~ 1 2
particle minecraft:ash ~ ~ ~ ~ ~ ~ 1 2 force
particle minecraft:ash ~ ~ ~ ~ ~ ~ 1 2 normal @e
```

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

### Execute command chain example

Source: https://kore.ayfri.com/docs/commands/execute

Demonstrates building an execute chain to target all players and have them say hello.

```kotlin
function("greet_nearby") {
	execute {
		asTarget(allPlayers())
		at(self())

		run {
			say("Hello!")
		}
	}
}
```

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

### Structure a pack with load and tick lifecycles

Source: https://kore.ayfri.com/docs/guides/cookbook

Split setup and recurring logic by using load for one-time initialization and tick for game loop execution. Registering objectives in tick is inefficient; use load for idempotent setup.

```kotlin
fun DataPack.registerCoreSystems() {
	load("setup") {
		scoreboard.objectives.add("round", "dummy")
		scoreboard.objectives.add("lives", "dummy")
	}

	tick("game_loop") {
		execute {
			asTarget(allPlayers())
			run {
				say("tick")
			}
		}
	}
}

fun main() = dataPack("arena") {
	registerCoreSystems()
}.generateZip()
```

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

### Projectile preview example

Source: https://kore.ayfri.com/docs/helpers/scoreboard-math

Demonstrates combining multiple math operations to build a complex simulation.

```kotlin
function("projectile_preview") {
	math.apply {
		sin(player, "launch_angle", "sin_angle")
		cos(player, "launch_angle", "cos_angle")
		parabola(player, "travel_time", "#launch_speed", "#gravity", "height_offset")
	}
}
```

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

### Shaped Crafting Examples

Source: https://kore.ayfri.com/docs/data-driven/recipes

Examples of 2x2 shaped crafting and using tags as ingredients.

```kotlin
// 2x2 recipe
craftingShaped("torch") {
    pattern(
	    "C",
	    "S"
    )
    keys {
	    "C" to Items.COAL
	    "S" to Items.STICK
    }
	result(Items.TORCH)
	count = 4
}

// Using tags as ingredients
craftingShaped("planks") {
	pattern("L")
	key("L", Tags.Item.LOGS)
	result(Items.OAK_PLANKS)
	count = 4
}
```

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

### Full legendary item example

Source: https://kore.ayfri.com/docs/data-driven/item-modifiers

A complete example demonstrating complex item modification, including attributes, lore, and usage within loot tables and commands.

```Kotlin
dataPack("legendary_items") {
	val legendaryModifier = itemModifier("legendary_weapon") {
		// High-level enchantments
		enchantWithLevels(levels = constant(30f)) {
			conditions {
				randomChance(0.3f)
			}
		}

		// Guaranteed enchantments
		setEnchantments {
			enchantment(Enchantments.UNBREAKING, 3)
		}

		// Custom name with formatting
		setName(textComponent("Legendary Weapon") {
			color = Color.GOLD
			bold = true
		})

		// Lore
		setLore {
			lore("Forged in ancient flames", Color.GRAY)
			lore("", Color.WHITE)
			lore("▸ +5 Attack Damage", Color.GREEN)
			mode(Mode.REPLACE_ALL)
		}

		// Attributes
		setAttributes(replace = false) {
			attribute(
				attribute = Attributes.ATTACK_DAMAGE,
				operation = AttributeModifierOperation.ADD_VALUE,
				amount = constant(5f),
				id = "legendary_damage",
				slot = EquipmentSlot.MAINHAND
			)
		}

		// Full durability
		setDamage(1.0f)
	}

	// Use in loot table
	lootTable("boss_weapon") {
		pool {
			rolls = constant(1f)

			entries {
				items(Items.DIAMOND_SWORD) {
					functions {
						reference(legendaryModifier)
					}
				}
			}
		}
	}

	// Use with command
	load {
		items {
			modify(self(), WEAPON.MAINHAND, legendaryModifier)
		}
	}
}
```

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

### Team Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates creating teams, modifying team properties, and managing player membership.

```Kotlin
function("team_examples") {
	teams.add("red_team", textComponent("Red Team"))
	teams.modify("red_team") {
		color(Color.RED)
		friendlyFire(false)
		seeFriendlyInvisibles(true)
	}
	teams.join("red_team", allPlayers())
	teams.leave(self())
}
```

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

### Bossbar Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates creating, configuring, and removing boss bars for UI progress tracking.

```Kotlin
function("bossbar_examples") {
	bossbar.add("my_bar", textComponent("My Boss Bar"))
	bossbar.set("my_bar") {
		color(BossBarColor.RED)
		max(100)
		value(50)
		visible(true)
		players(allPlayers())
		style(BossBarStyle.NOTCHED_10)
	}
	bossbar.remove("my_bar")
}
```

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

### Entity Predicate Example

Source: https://kore.ayfri.com/docs/data-driven/predicates

A comprehensive example demonstrating the use of entityProperties to check components, effects, equipment, flags, location, movement, NBT, and other entity-specific data.

```kotlin
predicate("entity_check") {
	entityProperties {
		// Check entity components (e.g., axolotl variant)
		components {
			axolotlVariant(AxolotlVariants.CYAN)
			damage(12)
			!unbreakable()  // Negated component check
		}

		// Check effects
		effects {
			this[Effects.INVISIBILITY] = mobEffectPredicate {
				amplifier = rangeOrInt(1)
			}
		}

		// Check equipment, one entry per equipment slot
		equipment {
			mainHand = itemStackPredicate(Items.DIAMOND_SWORD)
			body = itemStackPredicate(Items.SADDLE)
		}

		// Check entity flags
		flags {
			isBaby = true
		}

		// Check location
		location {
			block(Blocks.STONE)
		}

		// Check movement
		movement {
			x(1.0, 4.0)
			horizontalSpeed(1.0)
		}

		// Check what affects entity movement
		movementAffectedBy {
			canSeeSky = true
		}

		// Check NBT data
		nbt {
			this["foo"] = "bar"
		}

		// Check entity passenger
		passenger {
			team("foo")
		}

		// Check scoreboard tags set through /tag
		entityTags {
			allOf("boss")
			noneOf("tamed")
		}

		// Check the entity this one's AI is targeting
		targetedEntity {
			entityType(EntityTypes.VILLAGER)
		}

		// Check custom data predicates
		predicates {
			customData {
				this["foo"] = "bar"
			}
		}

		// Check specific inventory slots
		slots {
			this[WEAPON.MAINHAND] = itemStackPredicate(Items.DIAMOND_SWORD)
		}

		// Check block the entity is standing on
		steppingOn {
			block(Blocks.STONE) {
				components {
					damage(5)
				}
				predicates {
					customData {
						this["foo"] = "bar"
					}
				}
				state("up", "bottom")
			}
		}

		// Check entity type
		entityType(EntityTypes.MARKER)

		// Check player-specific properties
		typeSpecific {
			player {
				gamemodes(Gamemode.SURVIVAL)
			}
		}

		// Check entity vehicle with distance
		vehicle {
			distance {
				x(1f..4f)
				z(1f)
			}
		}
	}
}
```

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

### Using cooldown functions

Source: https://kore.ayfri.com/docs/oop/cooldowns

Shows how to start, check readiness, and reset a cooldown for a player.

```kotlin
function("combat") {
	with(cd) {
		start(player)               // sets the score to the duration
		ifReady(player) {           // runs only when score == 0, then restarts
			say("Attack ready!")
		}
		reset(player)               // forces score to 0
	}
}
```

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

### Loot Command Examples in Kotlin

Source: https://kore.ayfri.com/docs/commands/commands

Examples of using the loot command within a Kotlin function context to handle various loot generation and distribution scenarios.

```kotlin
function("loot_examples") {
	// roll a loot table and put the result straight into the player's inventory
	loot(self()) {
		loot(LootTables.Gameplay.CAT_MORNING_GIFT)
	}

	// roll it as if fished at a position with that rod, so rod enchantments apply
	loot(self()) {
		fish(LootTables.Gameplay.CAT_MORNING_GIFT, vec3(), Items.FISHING_ROD)
	}

	// roll the drops the entity would give if killed, without killing it
	loot(self()) {
		kill(self())
	}

	// roll the drops the block would give if mined with that tool
	loot(self()) {
		mine(vec3(), Items.DIAMOND_PICKAXE)
	}

	// drop the items into the container at that position instead of an inventory
	loot {
		target {
			insert(vec3())
		}
		source {
			kill(self())
		}
	}

	// overwrite one slot of a container block, CONTAINER[0] being its first slot
	loot {
		target {
			replaceBlock(vec3(), CONTAINER[0])
		}
		source {
			loot(LootTables.Gameplay.CAT_MORNING_GIFT)
		}
	}

	// overwrite an equipment slot, here the helmet
	loot {
		target {
			replaceEntity(self(), ARMOR.HEAD)
		}
		source {
			loot(LootTables.Gameplay.CAT_MORNING_GIFT)
		}
	}

	// mobs that carry their own inventory (villagers, piglins) use mob.inventory.*
	loot {
		target {
			replaceEntity(self(), MOB.INVENTORY[0])
		}
		source {
			loot(LootTables.Gameplay.CAT_MORNING_GIFT)
		}
	}

	// the source can also be a loot table written inline, with no separate file
	loot {
		target {
			give(self())
		}
		source {
			loot {
				pool {
					rolls(1f)
					entries {
						items(Items.ANVIL)
					}
				}
			}
		}
	}
}
```

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

### Int Provider usage examples

Source: https://kore.ayfri.com/docs/data-driven/worldgen/providers

Examples of various Int provider configurations used within count functions, including constant, biasedToBottom, clampedNormal, clamped, and weightedList distributions.

```kotlin
count(constant(10))
count(biasedToBottom(3, 8))
count(clampedNormal(1, 10, mean = 5.0f, deviation = 2.0f))

// Reroll uniform(0, 20), but never below 4 or above 12.
count(clamped(4, 12, uniform(0, 20)))

// 70% chance of 1, 30% chance of 3.
count(weightedList {
	entry(7, constant(1))
	entry(3, constant(3))
})

// Same pool, written as weight-to-provider pairs.
count(weightedList(7 to constant(1), 3 to constant(3)))
```

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

### Scoreboard Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates managing objectives and player scores using the scoreboard API.

```Kotlin
function("scoreboard_examples") {
	scoreboard.objectives.add("kills", ScoreboardCriteria.PLAYER_KILL_COUNT, textComponent("Player Kills"))
	scoreboard.objectives.remove("old_objective")
	scoreboard.objectives.setDisplay(DisplaySlots.sidebar, "kills")

	scoreboard.players.set(allPlayers(), "kills", 0)
	scoreboard.players.add(self(), "kills", 1)
	scoreboard.players.remove(self(), "kills", 5)
	scoreboard.players.reset(self(), "kills")

	scoreboard.players.operation(self(), "total", Operation.ADD, self(), "kills")
}
```

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

### Attribute Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates reading and modifying entity attributes and managing attribute modifiers.

```Kotlin
function("attribute_examples") {
	attribute(self(), Attributes.MAX_HEALTH) {
		get()
		base.get()
		base.set(40.0)
	}

	attribute(self(), Attributes.MOVEMENT_SPEED) {
		modifiers.add("speed_boost", 0.1, AttributeModifierOperation.ADD_VALUE)
		modifiers.remove("speed_boost")
	}
}
```

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

### Height provider usage examples

Source: https://kore.ayfri.com/docs/data-driven/worldgen/providers

Examples of using various height providers within a heightRange function, including uniform, trapezoid, constant, and weighted list distributions.

```kotlin
heightRange(uniformHeightProvider(minInclusive = 0, maxInclusive = 64))
heightRange(trapezoidHeightProvider(minInclusive = 0, maxInclusive = 64, plateau = 20))
heightRange(constantAbsolute(32))
heightRange(constantHeightProvider(belowTop(16)))
heightRange(veryBiasedToBottomHeightProvider(aboveBottom(8), absolute(16)))

heightRange(weightedListHeightProvider {
	entry(3, constantAbsolute(32))
	entry(1, uniformHeightProvider(aboveBottom(0), absolute(16)))
})
```

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

### Shapeless Crafting with Tags

Source: https://kore.ayfri.com/docs/data-driven/recipes

Example of a shapeless recipe using tags as ingredients.

```kotlin
craftingShapeless("dye_mix") {
	ingredient(Tags.Item.DYES)
	ingredient(Tags.Item.DYES)

	result(Items.MAGENTA_DYE)
	count = 2
}
```

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

### StopSound Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates stopping sounds for players, with options to filter by source or specific sound.

```Kotlin
function("stopsound_examples") {
	stopSound(self())
	stopSound(self(), PlaySoundMixer.MASTER)
	stopSound(self(), PlaySoundMixer.MASTER, Sounds.Mob.Bat.TAKEOFF)
	stopSoundAllSources(self())
	stopSoundAllSources(self(), Sounds.Mob.Bat.TAKEOFF)
}
```

```Mcfunction
stopsound @s
stopsound @s master
stopsound @s master minecraft:mob/bat/takeoff
stopsound @s *
stopsound @s * minecraft:mob/bat/takeoff
```

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

### Schedule Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates delaying function execution using ticks or seconds and clearing scheduled tasks.

```Kotlin
function("schedule_examples") {
	val myFunction = function("delayed_action") {
		say("This runs later!")
	}

	schedule.function(myFunction, 100.ticks)
	schedule.function(myFunction, 5.seconds, ScheduleMode.REPLACE)
	schedule.clear(myFunction)
}
```

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

### Configure Multiplatform Datapacks

Source: https://kore.ayfri.com/updates

Example showing the Kotlin multiplatform configuration and the usage of zip generation across targets, with filesystem access restricted to JVM and Node.js.

```kotlin
kotlin {
	jvm()
	js { browser(); nodejs() }
}

// works on every target
val zipBytes: ByteArray = pack.generateZipBytes()

// JVM/Node only, real filesystem
val datapack = exploreDatapackZip(zipBytes, "uploaded_pack.zip")
```

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

### Typical usage pattern for cooldowns

Source: https://kore.ayfri.com/docs/oop/cooldowns

Demonstrates separating the readiness check from the action that triggers the cooldown start.

```kotlin
function("dash_skill") {
	with(cd) {
		ifReady(player) {
			say("Dash!")
		}
	}
}

function("dash_hit") {
	cd.start(player)
}
```

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

### Structure Constants

Source: https://kore.ayfri.com/docs/advanced/test-features

Examples of using Kore's provided constants for vanilla Minecraft structures.

```Kotlin
// Examples
structure(Structures.AncientCity.Structures.BARRACKS)
structure(Structures.Bastion.Treasure.Bases.LAVA_BASIN)
structure(Structures.Igloo.TOP)
structure(Structures.TrialChambers.Chamber.ASSEMBLY)
structure(Structures.Village.Plains.Houses.PLAINS_SMALL_HOUSE_1)
```

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

### rideEntityInLava trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when riding an entity in lava, allowing configuration of distance and starting position.

```kotlin
rideEntityInLava("lava_ride") {
	distance {
		horizontal(10f)
	}
	startPosition {
		position {
			y = rangeOrInt(100..200)
		}
	}
}
```

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

### startedRiding trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when a player starts riding an entity, supporting conditions like entity type.

```kotlin
startedRiding("ride_horse") {
	conditions {
		vehicle {
			entityType(EntityTypes.HORSE)
		}
	}
}
```

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

### Entity Sub-Predicate Examples

Source: https://kore.ayfri.com/docs/data-driven/predicates

Examples of various sub-predicates used within the entityProperties condition.

```text
components { axolotlVariant(AxolotlVariants.CYAN) }
```

```text
distance { x(1f..4f) }
```

```text
effects { this[Effects.SPEED] = mobEffectPredicate { amplifier = rangeOrInt(1) } }
```

```text
entityTags { allOf("boss") }
```

```text
entityType(EntityTypes.MARKER)
```

```text
equipment { mainHand = itemStackPredicate(Items.DIAMOND_SWORD) }
```

```text
flags { isBaby = true }
```

```text
location { block(Blocks.STONE) }
```

```text
movement { x(1.0, 4.0); horizontalSpeed(1.0) }
```

```text
movementAffectedBy { canSeeSky = true }
```

```text
nbt { this["foo"] = "bar" }
```

```text
passenger { team("foo") }
```

```text
periodicTick(20)
```

```text
predicates { customData { this["key"] = "value" } }
```

```text
slots { this[WEAPON.MAINHAND] = itemStackPredicate(Items.DIAMOND_SWORD) }
```

```text
steppingOn { block(Blocks.STONE) }
```

```text
targetedEntity { entityType(EntityTypes.ZOMBIE) }
```

```text
team("my_team")
```

```text
vehicle { distance { x(1f..4f) } }
```

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

### Implement an Interactive Tutorial System

Source: https://kore.ayfri.com/docs/data-driven/dialogs

Creates a tutorial menu dialog that references other dialogs and includes an exit action to grant advancements.

```Kotlin
val tutorialDialog = dialogBuilder.dialogList("tutorials", "Tutorial Menu") {
	columns = 2
	buttonWidth = 180

	bodies {
		plainMessage("Choose a tutorial to begin:")
		items(Items.BOOK) {
			description = ItemDescription(textComponent("Learn the basics"))
		}
	}

	// Reference other tutorial dialogs
	dialogs(
		basicTutorial,
		advancedTutorial,
		pvpTutorial
	)

	exitAction("Skip Tutorials") {
		action {
			runCommand {
				advancement.grant(allPlayers(), AdvancementArgument("tutorial:skipped"))
			}
		}
	}
}
```

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

### Using the data command builder

Source: https://kore.ayfri.com/docs/commands/functions

Example of using the data command builder to modify entity data.

```kotlin
data(self()) {
	modify("Health", 20)
	modify("Inventory[0]", Items.DIAMOND_SWORD)
}
```

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

### Advanced styling and configuration examples

Source: https://kore.ayfri.com/docs/helpers/markdown-renderer

Demonstrates combining inline styles, setting custom link colors, using RGB color syntax, and applying styles within headings.

```kotlin
// Bold + italic combined
val styled = markdownToTextComponents("**bold and *italic* text**")

// Link with custom color
val link = markdownToTextComponents("Visit [Kore](https://kore.ayfri.com)") {
	linkColor = Color.GREEN
}

// Custom color syntax
val colored = markdownToTextComponents("§(#ff0000)red text§() normal text")

// Heading with inline styles
val heading = markdownToTextComponents("# Welcome to **Kore**")
```

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

### Spectate Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates how to enter spectator mode to view the game from another entity's perspective.

```Kotlin
function("spectate_examples") {
	spectate()               // stop spectating and return to your own body
	spectate(self())         // the entity to look through
	spectate(self(), self()) // target first, then which player does the spectating
}
```

```Mcfunction
spectate
spectate @s
spectate @s @s
```

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

### Reading values with get

Source: https://kore.ayfri.com/docs/concepts/data-storage

Use the get function to read values from storage. The scale parameter can be used to multiply numeric results.

```kotlin
function("show_level") {
	data(state) {
		get("level")              // data get storage my_pack:state level
		get("ratio", scale = 100.0) // read and scale the numeric result
	}
}
```

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

### Create Main.kt for a basic datapack

Source: https://kore.ayfri.com/docs/getting-started

Defines a datapack named 'starter_kore' with metadata and two functions, then generates a zip file.

```kotlin
fun main() {
	val datapack = dataPack("starter_kore") {
		pack {
			description = textComponent("Starter datapack generated with Kore")
		}

		function("hello") {
			tellraw(allPlayers(), textComponent("Hello from Kore"))
		}

		function("setup") {
			tellraw(allPlayers(), textComponent("Setup complete"))
		}
	}

	datapack.generateZip()
}
```

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

### Using the execute command builder

Source: https://kore.ayfri.com/docs/commands/functions

Example of using the complex execute command builder with selectors and conditional logic.

```kotlin
execute {
	asTarget(allEntities {
		limit = 3
		sort = Sort.RANDOM
	})

	ifCondition {
		score(self(), "test") lessThan 10
		predicate(myPredicate)
	}

	run { // be sure to import the run function, do not use the one from kotlin.
		teleport(entity)
	}
}
```

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

### Configure development vs release settings

Source: https://kore.ayfri.com/docs/guides/configuration

Example of using an environment variable to toggle configuration settings between development and release modes.

```Kotlin
val debug = System.getenv("KORE_DEBUG") != null

dataPack("mypack") {
	configuration {
		prettyPrint = debug
		generateCommentOfGeneratedFunctionCall = debug
	}
}
```

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

### Custom Tool Upgrade System Implementation

Source: https://kore.ayfri.com/docs/concepts/components

A complete example demonstrating how to define predicates for item detection and functions for modifying items, clearing inventory, and granting rewards based on specific item conditions.

```kotlin
dataPack("tool_upgrades") {
  // Predicate to find diamond swords that need upgrading
  predicate("upgradeable_sword") {
    matchTool {
      items(Items.DIAMOND_SWORD)
      predicates {
        // Must have Sharpness enchantment
        enchantments {
          enchantment(Enchantments.SHARPNESS, level = rangeOrInt(1..4))
        }
        // Must be damaged (durability used)
        damage {
          damage = rangeOrInt(1..1000)
        }
      }
    }
  }

  // Function to check player's held item and upgrade it
  function("check_upgrade") {
    // Check if holding an upgradeable sword
    execute {
      ifCondition {
        items(
          self(),
          ItemSlot.WEAPON_MAINHAND,
          Items.DIAMOND_SWORD.predicate {
            subPredicates {
              enchantments {
                enchantment(Enchantments.SHARPNESS, level = rangeOrInt(3..4))
              }
            }
          }
        )
      }
      run {
        // Replace with netherite sword keeping enchantments
        items.modify(self(), ItemSlot.WEAPON_MAINHAND, itemModifier("upgrade_to_netherite"))
        tellraw(self(), textComponent("Your sword has been upgraded!", Color.GOLD))
      }
    }
  }

  // Clear specific items from inventory using predicates
  function("clear_broken_tools") {
    // Clear any tool with 1 durability left
    clear(allPlayers(), itemPredicate {
      subPredicates {
        damage {
          durability = rangeOrInt(1)
        }
      }
    })
  }

  // Give reward only if player has specific item combination
  function("check_collection") {
    execute {
      // Check for a goat horn (any variant)
      ifCondition {
        items(
          self(),
          ItemSlot.INVENTORY,
          itemPredicate {
            isPresent(ItemComponentTypes.INSTRUMENT)
          }
        )
      }
      // Check for enchanted book with Mending
      ifCondition {
        items(
          self(),
          ItemSlot.INVENTORY,
          Items.ENCHANTED_BOOK.predicate {
            subPredicates {
              storedEnchantments {
                enchantment(Enchantments.MENDING)
              }
            }
          }
        )
      }
      run {
        give(self(), Items.NETHER_STAR)
      }
    }
  }
}
```

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

### usedTotem trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when a totem is used.

```kotlin
usedTotem("save_life") {
	item {
		items(Items.TOTEM_OF_UNDYING)
	}
}
```

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

### Vanilla Kore Mini-game Setup

Source: https://kore.ayfri.com/docs/oop/oop-utilities

A manual implementation of a mini-game using low-level command DSL, requiring manual scoreboard management and selector handling.

```Kotlin
dataPack("arena") {
	// --- Scoreboard objectives and teams ---
	function("setup") {
		scoreboard.objectives.add("kills", ScoreboardCriteria.DUMMY, textComponent("Kills"))
		scoreboard.objectives.add("game_state", ScoreboardCriteria.DUMMY)
		scoreboard.objectives.add("cooldown_dash", ScoreboardCriteria.DUMMY)
		teams {
			team("red") {
				color = FormattingColor.RED
				collisionRule = CollisionRule.PUSH_OTHER_TEAMS
			}
			team("blue") {
				color = FormattingColor.BLUE
				collisionRule = CollisionRule.PUSH_OTHER_TEAMS
			}
		}
	}

	// --- Player setup, selector rebuilt in each function ---
	function("join_red") {
		val player = allPlayers {
			limit = 1
			sort = Sort.NEAREST
		}
		teams.join("red", player)
		gamemode(Gamemode.SURVIVAL, player)
		effect(player) { give(Effects.SPEED, duration = 999999, amplifier = 1) }
		scoreboard.players.set(player, "kills", 0)
		scoreboard.players.set(player, "cooldown_dash", 0)
	}

	function("join_blue") {
		val player = allPlayers {
			limit = 1
			sort = Sort.NEAREST
		}
		teams.join("blue", player)
		gamemode(Gamemode.SURVIVAL, player)
		effect(player) { give(Effects.SPEED, duration = 999999, amplifier = 1) }
		scoreboard.players.set(player, "kills", 0)
		scoreboard.players.set(player, "cooldown_dash", 0)
	}

	// --- State transitions, tracked by hand on a fake player ---
	function("start_game") {
		scoreboard.players.set(literal("#game_state"), "game_state", 1)
		execute {
			asTarget(allPlayers())
			run {
				title(self()) {
					title(textComponent("Game Started!") {
						color = Color.GREEN
						bold = true
					})
				}
			}
		}
	}

	// --- Cooldown, decremented manually every tick ---
	function("tick_cooldowns") {
		execute {
			ifCondition {
				score(allPlayers(), "cooldown_dash", 1..Int.MAX_VALUE)
			}
			run {
				scoreboard.players.remove(allPlayers(), "cooldown_dash", 1)
			}
		}
	}

	// --- Spawning ---
	function("spawn_guardian") {
		summon(EntityTypes.IRON_GOLEM, vec3(0, 64, 0))
	}
}
```

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

### Gradle Build Step for Kore

Source: https://kore.ayfri.com/docs/advanced/github-actions-publishing

GitHub Actions steps to set up Java, ensure the Gradle wrapper is executable, and generate the datapack.

```yaml
      - name: Set up JDK 25
        uses: actions/setup-java@v5
        with:
			distribution: 'temurin'
	        java-version: 25

      - name: Ensure Gradle is executable
        run: chmod +x gradlew

      - name: Generate datapack
        run: ./gradlew run
```

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

### tameAnimal trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when an animal is tamed.

```kotlin
tameAnimal("tame_wolf") {
	entity {
		entityType(EntityTypes.WOLF)
	}
}
```

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

### recipeUnlocked trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when a recipe is unlocked.

```kotlin
recipeUnlocked("unlock_recipe", Recipes.DIAMOND)
```

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

### Clone Command Examples

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates various cloning operations including cross-dimension cloning, filtering, and strict mode to prevent corruption.

```kotlin
function("clone_examples") {
	// begin and end are the two opposite corners of the region to copy,
	// destination is where its lowest corner lands
	clone {
		begin = vec3(0, 64, 0)
		end = vec3(10, 74, 10)
		destination = vec3(100, 64, 100)
	}

	clone {
		begin = vec3(0, 64, 0)
		end = vec3(10, 74, 10)
		destination = vec3(0, 64, 0)
		from = Dimensions.THE_NETHER
		to = Dimensions.OVERWORLD
	}

	// masked skips air blocks, so the copy does not erase what is already there
	clone {
		begin = vec3(0, 64, 0)
		end = vec3(10, 74, 10)
		destination = vec3(100, 64, 100)
		masked(CloneMode.MOVE)
	}

	// only copies blocks matching the tag, everything else is left untouched
	clone {
		begin = vec3(0, 64, 0)
		end = vec3(10, 74, 10)
		destination = vec3(100, 64, 100)
		filter(Tags.Block.BASE_STONE_OVERWORLD, CloneMode.FORCE)
	}

	// source and destination overlap here, strict makes that fail instead of corrupting the copy
	clone {
		begin = vec3(0, 64, 0)
		end = vec3(10, 74, 10)
		destination = vec3(5, 64, 5)
		strict = true
	}
}
```

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

### usingItem trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers while using an item, such as a shield.

```kotlin
usingItem("shield_block") {
	item {
		items = listOf(Items.SHIELD)
	}
}
```

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

### Debug Commands Examples

Source: https://kore.ayfri.com/docs/commands/commands

Shows server debugging utilities for profiling, performance metrics, and Java Flight Recorder.

```Kotlin
function("debug_examples") {
	debugStart()
	debugStop()
	perfStart()
	perfStop()
	jfrStart()
	jfrStop()
}
```

```Mcfunction
debug start
debug stop
perf start
perf stop
jfr start
jfr stop
```

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

### sleptInBed trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when a player sleeps in a bed.

```kotlin
sleptInBed("sleep_in_bed")
```

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

### thrownItemPickedUpByPlayer trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when a thrown item is picked up by a player.

```kotlin
thrownItemPickedUpByPlayer("catch_trident") {
	item {
		items(Items.TRIDENT)
	}
}
```

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

### Executing raw command strings

Source: https://kore.ayfri.com/docs/commands/functions

Shows how to execute raw command strings, which is useful for commands not yet supported by the DSL or when using Macros.

```kotlin
addLine("say Hello from raw command!")
```

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

### slideDownBlock trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when sliding down a specific block type.

```kotlin
slideDownBlock("slide_down") {
	block {
		blocks(Blocks.SNOW_BLOCK)
	}
}
```

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

### Common player events

Source: https://kore.ayfri.com/docs/oop/events

Examples of various player-specific events available for registration.

```kotlin
val player = player("Steve")

player.onBlockUse { say("Interacted with a block!") }
player.onConsumeItem(Items.GOLDEN_APPLE) { say("Golden apple!") }
player.onFishingRodHooked { say("Got a bite!") }
player.onRecipeCrafted(Recipes.CRAFTING_TABLE) { say("Crafted a recipe!") }
player.onRightClick(Items.STICK) { say("Right click with stick!") }
player.onUsedTotem { say("Cheated death!") }
```

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

### DSL builder for raycast configuration

Source: https://kore.ayfri.com/docs/helpers/raycasts

Demonstrates how to define a raycast configuration using the raycast DSL and execute it within a function context.

```Kotlin
val ray = raycast {
	name = "my_ray"
	maxDistance = 50
	step = 0.5
	onHitBlock = { say("Hit!") }
	onMaxDistance = { say("Too far!") }
	onStep = { particle(Particles.FLAME, vec3()) }
}

function("use_ray") {
	with(ray) { cast() }
}
```

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

### JSON representation of BlendToGray

Source: https://kore.ayfri.com/docs/data-driven/worldgen/environment-attributes

The expanded JSON structure for the BlendToGray modifier example.

```JSON
{
	"argument": 16755200,
	"modifier": { "type": "blend_to_gray", "brightness": 0.5, "factor": 0.8 }
}
```

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

### Full Recipe Examples

Source: https://kore.ayfri.com/docs/data-driven/recipes

A comprehensive collection of various recipe types including shaped, shapeless, transmute, smelting, smithing, and stonecutting.

```Kotlin
dataPack("custom_recipes") {
    recipes {
	    // Shaped crafting with components
	    craftingShaped("legendary_sword") {
            pattern(
	            " N ",
	            " N ",
	            " B "
            )
            keys {
	            "N" to Items.NETHERITE_INGOT
	            "B" to Items.BLAZE_ROD
            }
		    result(Items.NETHERITE_SWORD) {
			    customName(textComponent("Blade of Flames", Color.GOLD))
                enchantments {
	                enchantment(Enchantments.FIRE_ASPECT, 2)
                    enchantment(Enchantments.SHARPNESS, 5)
                }
			    unbreakable()
            }
		    category = CraftingCategory.EQUIPMENT
        }

	    // Shapeless recipe
	    craftingShapeless("quick_tnt") {
		    ingredient(Items.GUNPOWDER)
		    ingredient(Items.GUNPOWDER)
		    ingredient(Items.GUNPOWDER)
		    ingredient(Items.GUNPOWDER)
		    ingredient(Tags.Item.SAND)
		    result(Items.TNT)
	    }

	    // Transmute recipe
	    craftingTransmute("repaint_bed") {
		    input(Tags.Item.BEDS)
		    material(Items.WHITE_DYE)
		    result(Items.WHITE_BED)
	    }

	    // Smelting with experience
	    smelting("ancient_debris") {
		    ingredient(Items.ANCIENT_DEBRIS)
		    result(Items.NETHERITE_SCRAP)
		    experience = 2.0
		    cookingTime = 200
		    category = SmeltingCategory.MISC
	    }

	    // Smithing upgrade
	    smithingTransform("netherite_boots") {
		    template(Items.NETHERITE_UPGRADE_SMITHING_TEMPLATE)
		    base(Items.DIAMOND_BOOTS)
		    addition(Items.NETHERITE_INGOT)
		    result(Items.NETHERITE_BOOTS)
	    }

	    // Smithing trim
	    smithingTrim("ward_trim") {
		    template(Items.WARD_ARMOR_TRIM_SMITHING_TEMPLATE)
		    base(Tags.Item.TRIMMABLE_ARMOR)
		    addition(Tags.Item.TRIM_MATERIALS)
		    pattern = TrimPatterns.WARD
	    }

	    // Stonecutting variants
	    stoneCutting("cut_copper_slab") {
		    ingredient(Items.COPPER_BLOCK)
		    result(Items.CUT_COPPER_SLAB)
		    count = 8
	    }
    }

	// Reference recipe in function
	val beaconRecipe = recipesBuilder.craftingShaped("easy_beacon") {
		pattern(
			"GGG",
			"GSG",
			"OOO"
		)
		keys {
			"G" to Items.GLASS
			"S" to Items.NETHER_STAR
			"O" to Items.OBSIDIAN
		}
		result(Items.BEACON)
	}

	load {
		recipeGive(allPlayers(), beaconRecipe)
	}
}
```

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

### WorldBorder Command Mcfunction Output

Source: https://kore.ayfri.com/docs/commands/commands

The Mcfunction equivalent of the worldborder command examples.

```mcfunction
worldborder add 10 200
worldborder set 1000
worldborder set 500 6000
worldborder center 0 0
worldborder damage amount 0.2
worldborder damage buffer 5
worldborder warning distance 10
worldborder warning time 15
worldborder get
```

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

### Clone Command Mcfunction Output

Source: https://kore.ayfri.com/docs/commands/commands

The Mcfunction equivalent of the clone command examples.

```mcfunction
clone 0 64 0 10 74 10 100 64 100
clone from minecraft:the_nether 0 64 0 10 74 10 to minecraft:overworld 0 64 0
clone 0 64 0 10 74 10 100 64 100 masked move
clone 0 64 0 10 74 10 100 64 100 filtered #minecraft:base_stone_overworld force
clone 0 64 0 10 74 10 5 64 5 strict
```

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

### spearMobs trigger example

Source: https://kore.ayfri.com/docs/data-driven/advancements/triggers

Triggers when a player spears a specified number of mobs.

```kotlin
spearMobs("spear_mobs") {
	count = 3
}
```

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

### Basic Execute Command

Source: https://kore.ayfri.com/docs/commands/commands

Demonstrates a basic execute command that targets all players and runs a say command.

```Kotlin
function("execute_basic") {
	execute {
		asTarget(allPlayers())

		run {
			say("Hello from execute!")
		}
	}
}
```

```Mcfunction
execute as @a run say Hello from execute!
```

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

### Full inventory manager example

Source: https://kore.ayfri.com/docs/helpers/inventory-manager

Combines player inventory policies with messaging and a chest that re-seeds its first slot, mirroring the internal test suite.

```kotlin
fun Function.inventoryManagerTests() {
    val counter = "take_counter"
    val playerInv = inventoryManager(nearestPlayer())

    playerInv.slotEvent(HOTBAR[0], Items.NETHER_STAR) {
        onTake {
            title(self(), TitleLocation.ACTIONBAR, text("Don’t take me", Color.RED))
            scoreboard.players.add(self(), counter, 1)
        }
        duringTake { setItemInSlot() }
        onTick { clearAllItemsNotInSlot(); killAllItemsNotInSlot() }
        setItemInSlot()
    }

    playerInv.generateSlotsListeners()

    datapack.load {
        scoreboard.objectives.add(counter)
        scoreboard.players.set(playerInv.container as ScoreHolderArgument, counter, 0)
    }

    inventoryManager(vec3(0, -59, 0)) {
        setBlock(Blocks.CHEST)
        slotEvent(CONTAINER[0], Items.DIAMOND_SWORD) {
            onTake { tellraw(allPlayers(), text("You took the diamond sword from the chest", Color.RED)) }
            duringTake { setItemInSlot() }
            onTick { clearAllItemsNotInSlot(); killAllItemsNotInSlot() }
            setItemInSlot()
        }
        generateSlotsListeners()
    }
}
```
Tokens:
Raw