Script API - v1.21.0
    Preparing search index...

    Interface EntityQueryOptions

    Contains options for selecting entities within an area.

    import { Dimension } from '@minecraft/server';

    // Having this command:

    // execute as @e[type=fox] positioned as @s if block ^ ^-1 ^ stone run summon salmon

    // Equivalent scripting code would be:
    function spawnFish(dimension: Dimension) {
    dimension
    .getEntities({
    type: 'fox',
    })
    .filter(entity => {
    const block = dimension.getBlock({
    x: entity.location.x,
    y: entity.location.y - 1,
    z: entity.location.z,
    });

    return block !== undefined && block.matches('minecraft:stone');
    })
    .forEach(entity => {
    dimension.spawnEntity('salmon', entity.location);
    });
    }
    import { Dimension } from '@minecraft/server';

    // Having this command:

    // execute as @e[type=armor_stand,name=myArmorStand,tag=dummyTag1,tag=!dummyTag2] run playsound raid.horn @a

    // Equivalent scripting code would be:
    function playSounds(dimension: Dimension) {
    const targetPlayers = dimension.getPlayers();
    const originEntities = dimension.getEntities({
    type: 'armor_stand',
    name: 'myArmorStand',
    tags: ['dummyTag1'],
    excludeTags: ['dummyTag2'],
    });

    originEntities.forEach(entity => {
    targetPlayers.forEach(player => {
    player.playSound('raid.horn');
    });
    });
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // Having this command:

    // execute as @e[has_property={propId=propValue}]

    // Equivalent scripting code would be:
    function findEntitiesHavingPropertyEqualsTo(propId: string, propValue: boolean | number | string) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId, value: { equals: propValue } }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // No equivalent commands as `propValue..` is inclusive in commands

    function findEntitiesHavingPropertyGreaterThan(propId: string, propValue: number) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId, value: { greaterThan: propValue } }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // Having this command:

    // execute as @e[has_property={propId=propValue..}]

    // Equivalent scripting code would be:
    function findEntitiesHavingPropertyGreaterThanOrEqualsTo(propId: string, propValue: number) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId, value: { greaterThanOrEquals: propValue } }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // Having this command:

    // execute as @e[has_property={property=propId}]

    // Equivalent scripting code would be:
    function findEntitiesHavingAProperty(propId: string) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // No equivalent commands as `..propValue` is inclusive in commands

    function findEntitiesHavingPropertyLessThan(propId: string, propValue: number) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId, value: { lessThan: propValue } }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // Having this command:

    // execute as @e[has_property={propId=..propValue}]

    // Equivalent scripting code would be:
    function findEntitiesHavingPropertyLessThanOrEqualsTo(propId: string, propValue: number) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId, value: { lessThanOrEquals: propValue } }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // Having this command:

    // execute as @e[has_property={propId=!propValue}]

    // Equivalent scripting code would be:
    function findEntitiesHavingPropertyNotEqualsTo(propId: string, propValue: boolean | number | string) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId, value: { notEquals: propValue } }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // Having this command:

    // execute as @e[has_property={property=!propId}]

    // Equivalent scripting code would be:
    function findEntitiesNotHavingAProperty(propId: string) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId, exclude: true }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { world, EntityQueryOptions } from '@minecraft/server';

    // Having this command:

    // execute as @e[has_property={propId=lowerBoundValue..upperBoundValue}]

    // Equivalent scripting code would be:
    function findEntitiesHavingPropertyWithinRange(propId: string, lowerBoundValue: number, upperBoundValue: number) {
    const queryOption: EntityQueryOptions = {
    propertyOptions: [{ propertyId: propId, value: { lowerBound: lowerBoundValue, upperBound: upperBoundValue } }]
    };

    const overworld = world.getDimension('overworld');
    const entities = overworld.getEntities(queryOption);
    }
    import { Dimension } from '@minecraft/server';

    // Having this command:

    // execute as @e[type=armor_stand,name=myArmorStand,tag=dummyTag1,tag=!dummyTag2] run tellraw @a { "rawtext": [{"translate": "hello.world" }] }

    // Equivalent scripting code would be:
    function sendMessagesToPlayers(dimension: Dimension) {
    const targetPlayers = dimension.getPlayers();
    const originEntities = dimension.getEntities({
    type: 'armor_stand',
    name: 'myArmorStand',
    tags: ['dummyTag1'],
    excludeTags: ['dummyTag2'],
    });

    originEntities.forEach(entity => {
    targetPlayers.forEach(player => {
    player.sendMessage({ rawtext: [{ translate: 'hello.world' }] });
    });
    });
    }
    import { Dimension, world } from '@minecraft/server';

    // Having these commands:

    // scoreboard objectives add scoreObjective1 dummy
    // scoreboard players set @e[type=armor_stand,name=myArmorStand] scoreObjective1 -1

    // Equivalent scripting code would be:
    function setScores(dimension: Dimension) {
    const objective = world.scoreboard.addObjective('scoreObjective1', 'dummy');
    dimension
    .getEntities({
    type: 'armor_stand',
    name: 'myArmorStand',
    })
    .forEach(entity => {
    if (entity.scoreboardIdentity !== undefined) {
    objective.setScore(entity.scoreboardIdentity, -1);
    }
    });
    }
    import { Dimension } from '@minecraft/server';

    // Having this command:

    // execute as @e[type=armor_stand] run execute as @a[x=0,y=-60,z=0,c=4,r=15] run summon pig ~1 ~ ~

    // Equivalent scripting code would be:
    function spawnPigs(dimension: Dimension) {
    const armorStandArray = dimension.getEntities({
    type: 'armor_stand',
    });
    const playerArray = dimension.getPlayers({
    location: { x: 0, y: -60, z: 0 },
    closest: 4,
    maxDistance: 15,
    });
    armorStandArray.forEach(entity => {
    playerArray.forEach(player => {
    dimension.spawnEntity('pig', {
    x: player.location.x + 1,
    y: player.location.y,
    z: player.location.z,
    });
    });
    });
    }
    interface EntityQueryOptions {
        closest?: number;
        excludeFamilies?: string[];
        excludeGameModes?: GameMode[];
        excludeNames?: string[];
        excludeTags?: string[];
        excludeTypes?: string[];
        families?: string[];
        farthest?: number;
        gameMode?: GameMode;
        location?: Vector3;
        maxDistance?: number;
        maxHorizontalRotation?: number;
        maxLevel?: number;
        maxVerticalRotation?: number;
        minDistance?: number;
        minHorizontalRotation?: number;
        minLevel?: number;
        minVerticalRotation?: number;
        name?: string;
        scoreOptions?: EntityQueryScoreOptions[];
        tags?: string[];
        type?: string;
        volume?: Vector3;
    }

    Hierarchy (View Summary)

    Index

    Properties

    closest?: number

    Limits the number of entities to return, opting for the closest N entities as specified by this property. The location value must also be specified on the query options object.

    excludeFamilies?: string[]

    Excludes entities that match one or more of the specified families.

    excludeGameModes?: GameMode[]

    Excludes entities if have a specific gamemode that matches the specified gamemode.

    excludeNames?: string[]

    Excludes entities that have a name that match one of the specified values.

    excludeTags?: string[]

    Excludes entities with a tag that matches one of the specified values.

    excludeTypes?: string[]

    Excludes entities if they are one of the specified types.

    families?: string[]

    If specified, includes entities that match all of the specified families.

    farthest?: number

    Limits the number of entities to return, opting for the farthest N entities as specified by this property. The location value must also be specified on the query options object.

    gameMode?: GameMode

    If specified, includes entities with a gamemode that matches the specified gamemode.

    location?: Vector3

    Adds a seed location to the query that is used in conjunction with closest, farthest, limit, volume, and distance properties.

    maxDistance?: number

    If specified, includes entities that are less than this distance away from the location specified in the location property.

    maxHorizontalRotation?: number

    If specified, will only include entities that have at most this horizontal rotation.

    maxLevel?: number

    If defined, only players that have at most this level are returned.

    maxVerticalRotation?: number

    If specified, only entities that have at most this vertical rotation are returned.

    minDistance?: number

    If specified, includes entities that are least this distance away from the location specified in the location property.

    minHorizontalRotation?: number

    If specified, will only include entities that have at a minimum this horizontal rotation.

    minLevel?: number

    If defined, only players that have at least this level are returned.

    minVerticalRotation?: number

    If specified, will only include entities that have at least this vertical rotation.

    name?: string

    Includes entities with the specified name.

    scoreOptions?: EntityQueryScoreOptions[]

    Gets/sets a collection of EntityQueryScoreOptions objects with filters for specific scoreboard objectives.

    tags?: string[]

    Includes entities that match all of the specified tags.

    type?: string

    If defined, entities that match this type are included.

    volume?: Vector3

    In conjunction with location, specified a cuboid volume of entities to include.