BetaBetaVolume of blocks that will be checked.
Block filter that will be checked against each block in the volume.
OptionalallowUnloadedChunks: booleanIf set to true will suppress the UnloadedChunksError if some or all of the block volume is outside of the loaded chunks. Will only check the block locations that are within the loaded chunks in the volume.
Returns true if at least one block in the volume satisfies the filter, false otherwise.
BetaThe location of the explosion.
Radius, in blocks, of the explosion to create.
OptionalexplosionOptions: ExplosionOptionsAdditional configurable options for the explosion.
Creates an explosion at the specified location.
This function can't be called in read-only mode.
// Creates an explosion of radius 15 that does not break blocks
import { DimensionLocation } from '@minecraft/server';
function createExplosions(location: DimensionLocation) {
// Creates an explosion of radius 15 that does not break blocks
location.dimension.createExplosion(location, 15, { breaksBlocks: false });
// Creates an explosion of radius 15 that does not cause fire
location.dimension.createExplosion(location, 15, { causesFire: true });
// Creates an explosion of radius 10 that can go underwater
location.dimension.createExplosion(location, 10, { allowUnderwater: true });
}
BetaType of block to fill the volume with.
Optionaloptions: BlockFillOptionsA set of additional options, such as a matching block to potentially replace this fill block with.
Returns number of blocks placed.
Fills an area between begin and end with block of type block.
This function can't be called in read-only mode.
import { BlockPermutation, BlockVolume, world } from "@minecraft/server";
// Command: /fill 0 10 0 20 30 40 tnt["allow_underwater_bit"=true] replace air
const overworld = world.getDimension("overworld");
const volume = new BlockVolume({ x: 0, y: 10, z: 0 }, { x: 20, y: 30, z: 40 });
const tnt = BlockPermutation.resolve("minecraft:tnt", {
allow_underwater_bit: true,
});
overworld.fillBlocks(volume, tnt, {
blockFilter: { excludeTypes: ["minecraft:air"] },
});
import {
BlockPermutation,
BlockVolume,
Dimension,
Vector3,
world,
} from "@minecraft/server";
function fillBlockType(
dimension: Dimension,
from: Vector3,
to: Vector3,
block: string
): void {
const volume = new BlockVolume(from, to);
dimension.fillBlocks(volume, block);
}
// Command: /fill 0 10 0 20 30 40 diamond_block
const overworld = world.getDimension("overworld");
fillBlockType(
overworld,
{ x: 0, y: 10, z: 0 },
{ x: 20, y: 30, z: 40 },
"minecraft:diamond_block"
);
BetaStarting location to look for a biome to find.
Identifier of the biome to look for.
Optionaloptions: BiomeSearchOptionsAdditional selection criteria for a biome search.
Returns a location of the biome, or undefined if a biome could not be found.
Finds the location of the closest biome of a particular type. Note that the findClosestBiome operation can take some time to complete, so avoid using many of these calls within a particular tick.
This function can't be called in read-only mode.
import { BiomeTypes, Player } from "@minecraft/server";
const biomeTypes = BiomeTypes.getAll();
// Finds which biome player is in currently
function getBiome(player: Player): string {
for (const currentBiome of biomeTypes) {
const biome = player.dimension.findClosestBiome(
player.location,
currentBiome,
{ boundingSize: { x: 64, y: 64, z: 64 } }
);
if (biome !== undefined) {
return currentBiome.id;
}
}
throw new Error("Player is not in any biome");
}
BetaOptionaloptions: BlockRaycastOptionsBetaOptionaloptions: BlockRaycastOptionsBetaLocation from where to initiate the ray check.
Vector direction to cast the ray.
Optionaloptions: BlockRaycastOptionsAdditional options for processing this raycast query.
BetaVolume of blocks that will be checked.
Block filter that will be checked against each block in the volume.
OptionalallowUnloadedChunks: booleanIf set to true will suppress the UnloadedChunksError if some or all of the block volume is outside of the loaded chunks. Will only check the block locations that are within the loaded chunks in the volume.
Returns the ListBlockVolume that contains all the block locations that satisfied the block filter.
import {
BlockPermutation,
BlockVolume,
system,
world,
} from "@minecraft/server";
// Get every non-air block location at chunk (0, 0)
const overworld = world.getDimension("overworld");
const volume = new BlockVolume(
{ x: 0, y: overworld.heightRange.min, z: 0 },
{ x: 15, y: overworld.heightRange.max, z: 15 }
);
const locations = overworld.getBlocks(
volume,
{ excludeTypes: ["minecraft:air"] },
false
);
// A simple generator that replace non-air blocks to cobblestone at chunk (0, 0),
// yielding after each block placement.
function* blockPlacingGenerator() {
for (const location of locations.getBlockLocationIterator()) {
const block = overworld.getBlock(location);
block.setPermutation(BlockPermutation.resolve("minecraft:cobblestone"));
yield;
}
}
system.runJob(blockPlacingGenerator());
BetaOptionaloptions: EntityQueryOptionsAdditional options that can be used to filter the set of entities returned.
An entity array.
Returns a set of entities based on a set of conditions defined via the EntityQueryOptions set of filter criteria.
import { DimensionLocation, EntityComponentTypes } from "@minecraft/server";
// Returns true if a feather item entity is within 'distance' blocks of 'location'.
function isFeatherNear(location: DimensionLocation, distance: number): boolean {
const items = location.dimension.getEntities({
location: location,
maxDistance: 20,
});
for (const item of items) {
const itemComp = item.getComponent(EntityComponentTypes.Item);
if (itemComp) {
if (itemComp.itemStack.typeId.endsWith('feather')) {
return true;
}
}
}
return false;
}
import { EntityQueryOptions, DimensionLocation } from '@minecraft/server';
function mobParty(targetLocation: DimensionLocation) {
const mobs = ['creeper', 'skeleton', 'sheep'];
// create some sample mob data
for (let i = 0; i < 10; i++) {
const mobTypeId = mobs[i % mobs.length];
const entity = targetLocation.dimension.spawnEntity(mobTypeId, targetLocation);
entity.addTag('mobparty.' + mobTypeId);
}
const eqo: EntityQueryOptions = {
tags: ['mobparty.skeleton'],
};
for (const entity of targetLocation.dimension.getEntities(eqo)) {
entity.kill();
}
}
import { EntityQueryOptions, GameMode, world } from "@minecraft/server";
const options: EntityQueryOptions = {
families: ["mob", "animal"],
excludeTypes: ["cow"],
maxDistance: 50,
excludeGameModes: [GameMode.creative, GameMode.spectator],
};
const filteredEntities = world.getDimension("overworld").getEntities(options);
console.log(
"Filtered Entities:",
filteredEntities.map((entity) => entity.typeId)
);
BetaOptionaloptions: EntityRaycastOptionsAdditional options for processing this raycast query.
BetaOptionaloptions: EntityQueryOptionsAdditional options that can be used to filter the set of players returned.
A player array.
Returns a set of players based on a set of conditions defined via the EntityQueryOptions set of filter criteria.
import { EntityQueryOptions, world } from "@minecraft/server";
const entityQueryOptions: EntityQueryOptions = {
maxDistance: 100,
scoreOptions: [
{ objective: "kills", minScore: 10 },
{ objective: "deaths", maxScore: 5 },
],
};
const filteredPlayers = world
.getDimension("overworld")
.getPlayers(entityQueryOptions);
console.log(
"Filtered Players in Overworld:",
filteredPlayers.map((player) => player.name)
);
BetaReturns a WeatherType that explains the broad category of weather that is currently going on.
BetaIdentifier of the sound.
Location of the sound.
OptionalsoundOptions: WorldSoundOptionsAdditional options for configuring additional effects for the sound.
An error will be thrown if volume is less than 0.0. An error will be thrown if fade is less than 0.0. An error will be thrown if pitch is less than 0.01. An error will be thrown if volume is less than 0.0.
import { world, MusicOptions, WorldSoundOptions, PlayerSoundOptions, Vector3 } from '@minecraft/server';
import { MinecraftDimensionTypes } from '@minecraft/vanilla-data';
const players = world.getPlayers();
const targetLocation: Vector3 = {
x: 0,
y: 0,
z: 0,
};
const musicOptions: MusicOptions = {
fade: 0.5,
loop: true,
volume: 1.0,
};
world.playMusic('music.menu', musicOptions);
const worldSoundOptions: WorldSoundOptions = {
pitch: 0.5,
volume: 4.0,
};
const overworld = world.getDimension(MinecraftDimensionTypes.Overworld);
overworld.playSound('ambient.weather.thunder', targetLocation, worldSoundOptions);
const playerSoundOptions: PlayerSoundOptions = {
pitch: 1.0,
volume: 1.0,
};
players[0].playSound('bucket.fill_water', playerSoundOptions);
BetaCommand to run. Note that command strings should not start with slash.
Returns a command result with a count of successful values from the command.
Runs a command synchronously using the context of the broader dimenion.
This function can't be called in read-only mode.
BetaCommand to run. Note that command strings should not start with slash.
For commands that return data, returns a CommandResult with an indicator of command results.
BetaThe location within the dimension to set the block.
The block permutation to set.
BetaSet the type of weather to apply.
Optionalduration: numberSets the duration of the weather (in ticks). If no duration is provided, the duration will be set to a random duration between 300 and 900 seconds.
BetaIdentifier of the type of entity to spawn. If no namespace is specified, 'minecraft:' is assumed.
The location at which to create the entity.
Optionaloptions: SpawnEntityOptionsNewly created entity at the specified location.
Creates a new entity (e.g., a mob) at the specified location.
This function can't be called in read-only mode.
// Spawns an adult horse
import { DimensionLocation } from '@minecraft/server';
function spawnAdultHorse(location: DimensionLocation) {
// Create a horse and triggering the 'ageable_grow_up' event, ensuring the horse is created as an adult
location.dimension.spawnEntity('minecraft:horse<minecraft:ageable_grow_up>', location);
}
// Spawns a fox over a dog
import { DimensionLocation } from '@minecraft/server';
import { MinecraftEntityTypes } from '@minecraft/vanilla-data';
function spawnAdultHorse(location: DimensionLocation) {
// Create fox (our quick brown fox)
const fox = location.dimension.spawnEntity(MinecraftEntityTypes.Fox, {
x: location.x,
y: location.y + 2,
z: location.z,
});
fox.addEffect('speed', 10, {
amplifier: 2,
});
// Create wolf (our lazy dog)
const wolf = location.dimension.spawnEntity(MinecraftEntityTypes.Wolf, location);
wolf.addEffect('slowness', 10, {
amplifier: 2,
});
wolf.isSneaking = true;
}
BetaNewly created item stack entity at the specified location.
Creates a new item stack as an entity at the specified location.
This function can't be called in read-only mode.
// Spawns a feather at a location
import { ItemStack, DimensionLocation } from '@minecraft/server';
import { MinecraftItemTypes } from '@minecraft/vanilla-data';
function spawnFeather(location: DimensionLocation) {
const featherItem = new ItemStack(MinecraftItemTypes.Feather, 1);
location.dimension.spawnItem(featherItem, location);
}
BetaIdentifier of the particle to create.
The location at which to create the particle emitter.
OptionalmolangVariables: MolangVariableMapA set of optional, customizable variables that can be adjusted for this particle.
Creates a new particle emitter at a specified location in the world.
This function can't be called in read-only mode.
// A function that spawns a particle at a random location near the target location for all players in the server
import { world, MolangVariableMap, DimensionLocation, Vector3 } from '@minecraft/server';
function spawnConfetti(location: DimensionLocation) {
for (let i = 0; i < 100; i++) {
const molang = new MolangVariableMap();
molang.setColorRGB('variable.color', {
red: Math.random(),
green: Math.random(),
blue: Math.random()
});
const newLocation: Vector3 = {
x: location.x + Math.floor(Math.random() * 8) - 4,
y: location.y + Math.floor(Math.random() * 8) - 4,
z: location.z + Math.floor(Math.random() * 8) - 4,
};
location.dimension.spawnParticle('minecraft:colored_flame_particle', newLocation, molang);
}
}
A class that represents a particular dimension (e.g., The End) within a world.