Class Entity

Readonlydimension

import { ItemStack, world } from "@minecraft/server";

for (const entity of world.getDimension("overworld").getEntities()) {
    entity.dimension.spawnItem(
        new ItemStack("minecraft:diamond_sword"),
        entity.location
    );
}
Copy

Readonlyid

import { Entity, world } from "@minecraft/server";

/**
 * Gets entity id
 * @param {Entity} entity
 */
function showId(entity) {
    entity.runCommandAsync("say My entity ID: " + entity.id);
}

for (const entity of world.getDimension("overworld").getEntities()) {
    showId(entity);
}
Copy

ReadonlyisClimbing

import { system, world } from "@minecraft/server";

system.runInterval(() => {
    // Get all overworld entities
    for (const entity of world.getDimension("overworld").getEntities()) {
        if (entity.isClimbing) {
            entity.runCommand("say I'm climbing!");
        }
    }
});
Copy

ReadonlyisFalling

import { system, world } from "@minecraft/server";

system.runInterval(() => {
    for (const player of world.getAllPlayers()) {
        player.sendMessage(`isClimbing - ${player.isClimbing}`);
    }
});
Copy

ReadonlyisInWater

import { system, world } from "@minecraft/server";

system.runInterval(() => {
    for (const player of world.getAllPlayers()) {
        player.sendMessage(`player in water: ${player.isInWater}`);
    }
});
Copy

ReadonlyisOnGround

import { system, world } from "@minecraft/server";

system.runInterval(() => {
    for (const player of world.getAllPlayers()) {
        player.sendMessage(`player on ground: ${player.isOnGround}`);
    }
});
Copy

ReadonlyisSleeping

isSneaking

import { system, world } from "@minecraft/server";

system.runInterval(() => {
    for (const entity of world.getDimension("overworld").getEntities()) {
        // Force entity to not sneak
        entity.isSneaking = false;
    }
});
Copy

import {
    DimensionLocation,
    MolangVariableMap,
    Vector3,
    system,
    world,
} 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
        );
    }
}

system.runInterval(() => {
    for (const player of world.getPlayers()) {
        if (player.isSneaking) {
            spawnConfetti({
                dimension: player.dimension,
                x: player.location.x,
                y: player.location.y,
                z: player.location.z,
            });
            player.sendMessage("player is sneaking");
        }
    }
});
Copy

ReadonlyisSprinting

ReadonlyisSwimming

Readonlylocation

import { world } from "@minecraft/server";

world.afterEvents.buttonPush.subscribe((event) => {
    if (event.source.typeId === "minecraft:player") {
        event.source.kill();
    }
});
Copy

nameTag

import { system, world } from "@minecraft/server";

system.afterEvents.scriptEventReceive.subscribe(({ message }) => {
    if (message === "dinnerbone:true") {
        for (const entity of world.getDimension("overworld").getEntities()) {
            entity.nameTag = "Dinnerbone";
        }
    }
});
Copy

Optional ReadonlyscoreboardIdentity

Optional Readonly Betatarget

ReadonlytypeId

import { system, world } from "@minecraft/server";

// This event triggers when world is loaded
system.runInterval(() => {
    const entity = world.getDimension("overworld").getEntities()[0];
    // Finally, show that location as title
    entity.runCommandAsync(
        `title @a actionbar X: ${Math.floor(
            entity.location.x
        )} | Y: ${Math.floor(entity.location.y)} | Z: ${Math.floor(
            entity.location.z
        )}`
    );
});
Copy

addEffect

• addEffect(
      effectType: string | EffectType,
      duration: number,
      options?: EntityEffectOptions,
  ): Effect

• Parameters

  • effectType: string | EffectType

    Type of effect to add to the entity.
  • duration: number

    Amount of time, in ticks, for the effect to apply. There are 20 ticks per second. Use TicksPerSecond constant to convert between ticks and seconds. The value must be within the range [0, 20000000].
  • Optionaloptions: EntityEffectOptions

    Additional options for the effect.

  Returns Effect

  Returns nothing if the effect was added or updated successfully. This can throw an error if the duration or amplifier are outside of the valid ranges, or if the effect does not exist.

  Remarks

  Adds or updates an effect, like poison, to the entity.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: spawnPoisonedVillager.ts

  import { DimensionLocation } from "@minecraft/server";
  import { MinecraftEffectTypes } from "@minecraft/vanilla-data";
  
  function spawnPoisonedVillager(
      targetLocation: DimensionLocation
  ) {
    const villagerType = "minecraft:villager_v2<minecraft:ageable_grow_up>";
    const villager = targetLocation.dimension.spawnEntity(villagerType, targetLocation);
    const duration = 20;
  
    villager.addEffect(MinecraftEffectTypes.Poison, duration, { amplifier: 1 });
  }
  Copy

  Example: quickFoxLazyDog.ts

  import { DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes, MinecraftEffectTypes } from "@minecraft/vanilla-data";
  
  function quickFoxLazyDog(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
    const fox = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Fox, {
      x: targetLocation.x + 1,
      y: targetLocation.y + 2,
      z: targetLocation.z + 3,
    });
  
    fox.addEffect(MinecraftEffectTypes.Speed, 10, {
      amplifier: 2,
    });
    log("Created a fox.");
  
    const wolf = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Wolf, {
      x: targetLocation.x + 4,
      y: targetLocation.y + 2,
      z: targetLocation.z + 3,
    });
    wolf.addEffect(MinecraftEffectTypes.Slowness, 10, {
      amplifier: 2,
    });
    wolf.isSneaking = true;
    log("Created a sneaking wolf.", 1);
  }
  Copy

addTag

• addTag(tag: string): boolean

• Parameters

  • tag: string

    Content of the tag to add. The tag must be less than 256 characters.

  Returns boolean

  Returns true if the tag was added successfully. This can fail if the tag already exists on the entity.

  Remarks

  Adds a specified tag to an entity.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: tagsQuery.ts

  import { EntityQueryOptions, DimensionLocation } from "@minecraft/server";
  
  function tagsQuery(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();
    }
  }
  Copy

applyDamage

• applyDamage(
      amount: number,
      options?: EntityApplyDamageByProjectileOptions | EntityApplyDamageOptions,
  ): boolean

• Parameters

  • amount: number

    Amount of damage to apply.
  • Optionaloptions: EntityApplyDamageByProjectileOptions | EntityApplyDamageOptions

    Additional options about the source of damage, which may add additional effects or spur additional behaviors on this entity.

  Returns boolean

  Whether the entity takes any damage. This can return false if the entity is invulnerable or if the damage applied is less than or equal to 0.

  Remarks

  Applies a set of damage to an entity.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: applyDamageThenHeal.ts

  import { system, EntityHealthComponent, EntityComponentTypes, DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes } from "@minecraft/vanilla-data";
  
  function applyDamageThenHeal(
    log: (message: string, status?: number) => void,
    targetLocation: DimensionLocation
  ) {
    const skelly = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Skeleton, targetLocation);
  
    skelly.applyDamage(19); // skeletons have max damage of 20 so this is a near-death skeleton
  
    system.runTimeout(() => {
      const health = skelly.getComponent(EntityComponentTypes.Health) as EntityHealthComponent;
      log("Skeleton health before heal: " + health?.currentValue);
      health?.resetToMaxValue();
      log("Skeleton health after heal: " + health?.currentValue);
    }, 20);
  }
  Copy

  Example: applyWither.js

  import { world, EntityDamageCause } from "@minecraft/server";
  const player = world.getAllPlayers()[0];
  player.applyDamage(1000, {
      cause: EntityDamageCause.wither,
  });
  Copy

  Example: damageEntity.js

  import { world } from "@minecraft/server";
  world.afterEvents.itemUse.subscribe((event) => {
      const player = event.source;
      const damageApplied = player.applyDamage(10);
      console.log(`Damage applied: ${damageApplied}`);
  });
  Copy

applyImpulse

• applyImpulse(vector: Vector3): void

• Parameters

  • vector: Vector3

    Impulse vector.

  Returns void

  Remarks

  Applies impulse vector to the current velocity of the entity.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: applyImpulse.ts

  import { DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes } from "@minecraft/vanilla-data";
  
  function applyImpulse(targetLocation: DimensionLocation) {
    const zombie = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Zombie, targetLocation);
  
    zombie.clearVelocity();
  
    // throw the zombie up in the air
    zombie.applyImpulse({ x: 0, y: 0.5, z: 0 });
  }
  Copy

applyKnockback

• applyKnockback(
      directionX: number,
      directionZ: number,
      horizontalStrength: number,
      verticalStrength: number,
  ): void

• Parameters

  • directionX: number

    X direction in horizontal plane.
  • directionZ: number

    Z direction in horizontal plane.
  • horizontalStrength: number

    Knockback strength for the horizontal vector.
  • verticalStrength: number

    Knockback strength for the vertical vector.

  Returns void

  Remarks

  Applies impulse vector to the current velocity of the entity.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: bounceSkeletons.ts

  import { EntityQueryOptions, DimensionLocation } from "@minecraft/server";
  
  function bounceSkeletons(targetLocation: DimensionLocation) {
    const mobs = ["creeper", "skeleton", "sheep"];
  
    // create some sample mob data
    for (let i = 0; i < 10; i++) {
      targetLocation.dimension.spawnEntity(mobs[i % mobs.length], targetLocation);
    }
  
    const eqo: EntityQueryOptions = {
      type: "skeleton",
    };
  
    for (const entity of targetLocation.dimension.getEntities(eqo)) {
      entity.applyKnockback(0, 0, 0, 1);
    }
  }
  Copy

clearDynamicProperties

• clearDynamicProperties(): void

• Returns void

  Remarks

  Clears all dynamic properties that have been set on this entity.

  Throws

  This function can throw errors.

  Example: resetStats.js

  import { world } from "@minecraft/server";
  
  for (const entity of world.getDimension("overworld").getEntities()) {
      entity.clearDynamicProperties();
  }
  Copy

clearVelocity

• clearVelocity(): void

• Returns void

  Remarks

  Sets the current velocity of the Entity to zero. Note that this method may not have an impact on Players.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: applyImpulse.ts

  import { DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes } from "@minecraft/vanilla-data";
  
  function applyImpulse(targetLocation: DimensionLocation) {
    const zombie = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Zombie, targetLocation);
  
    zombie.clearVelocity();
  
    // throw the zombie up in the air
    zombie.applyImpulse({ x: 0, y: 0.5, z: 0 });
  }
  Copy

extinguishFire

• extinguishFire(useEffects?: boolean): boolean

• Parameters

  • OptionaluseEffects: boolean

    Whether to show any visual effects connected to the extinguishing.

  Returns boolean

  Returns whether the entity was on fire.

  Remarks

  Extinguishes the fire if the entity is on fire. Note that you can call getComponent('minecraft:onfire') and, if present, the entity is on fire.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: setOnFire.ts

  import { system, EntityOnFireComponent, EntityComponentTypes, DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes } from "@minecraft/vanilla-data";
  
  function setOnFire(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
    const skelly = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Skeleton, targetLocation);
  
    skelly.setOnFire(20, true);
  
    system.runTimeout(() => {
      const onfire = skelly.getComponent(EntityComponentTypes.OnFire) as EntityOnFireComponent;
      log(onfire?.onFireTicksRemaining + " fire ticks remaining.");
  
      skelly.extinguishFire(true);
      log("Never mind. Fire extinguished.");
    }, 20);
  }
  Copy

getBlockFromViewDirection

• getBlockFromViewDirection(options?: BlockRaycastOptions): BlockRaycastHit

• Parameters

  • Optionaloptions: BlockRaycastOptions

    Additional configuration options for the ray cast.

  Returns BlockRaycastHit

  Returns the first intersecting block from the direction that this entity is looking at.

  Remarks

  Returns the first intersecting block from the direction that this entity is looking at.

  Throws

  This function can throw errors.

  Example: facingBlock.js

  import { world } from "@minecraft/server";
  
  for (const entity of world.getDimension("overworld").getEntities()) {
      const blockHit = entity.getBlockFromViewDirection();
  
      if (blockHit) {
          console.log("Block Hit:");
          console.log("Block:", blockHit.block);
          console.log("Face:", blockHit.face);
          console.log("Face Location:", JSON.stringify(blockHit.faceLocation));
      } else {
          console.log("No block in view direction.");
      }
  }
  Copy

  Example: setBedrock.js

  import { BlockPermutation, world } from "@minecraft/server";
  
  const entity = world
      .getDimension("overworld")
      .spawnEntity("minecraft:fox", { x: 0, y: 0, z: 0 });
  const blockHit = entity.getBlockFromViewDirection();
  
  if (blockHit) {
      blockHit.block.setPermutation(
          BlockPermutation.resolve("minecraft:bedrock")
      );
  } else {
      console.log("No block in view direction.");
  }
  Copy

getComponent

• getComponent<T extends keyof EntityComponentTypeMap>(
      componentId: T,
  ): EntityComponentTypeMap[T]

• Type Parameters

  • T extends keyof EntityComponentTypeMap

  Parameters

  • componentId: T

    The identifier of the component (e.g., 'minecraft:health'). If no namespace prefix is specified, 'minecraft:' is assumed. Available component IDs can be found as part of the EntityComponentTypes enum.

  Returns EntityComponentTypeMap[T]

  Returns the component if it exists on the entity, otherwise undefined.

  Remarks

  Gets a component (that represents additional capabilities) for an entity.

  Example: entityHealth.js

  import { world } from "@minecraft/server";
  
  for (const player of world.getPlayers()) {
      const health = player.getComponent("health");
      player.sendMessage(
          "Your health is " + health.currentValue + "/" + health.effectiveMax
      );
      health.setCurrentValue(15); // set player to 15 hp
      health.resetToMaxValue(); // reset player to max hp
  }
  Copy

  Example: entityInventory.js

  import { ItemStack, world } from "@minecraft/server";
  
  world.afterEvents.buttonPush.subscribe((event) => {
      const entity = event.source;
      entity
          .getComponent("inventory")
          .container.addItem(new ItemStack("minecraft:dirt", 1));
  });
  Copy

  Example: entityItem.js

  import { world } from "@minecraft/server";
  
  const itemEntities = world
      .getDimension("overworld")
      .getEntities({ type: "minecraft:item" });
  for (const itemEntity of itemEntities) {
      const item = itemEntity.getComponent("item");
      item.itemStack.keepOnDeath = true;
  }
  Copy

getComponents

• getComponents(): EntityComponent[]

• Returns EntityComponent[]

  Returns all components that are both present on this entity and supported by the API.

  Remarks

  Returns all components that are both present on this entity and supported by the API.

  Example: getComponents.js

  import { world } from "@minecraft/server";
  
  for (const entity of world.getDimension("overworld").getEntities()) {
      const components = entity.getComponents();
      console.log(
          `Number of components: ${components.length}: ${components.map(
              (component) => component.typeId
          )}`
      );
  }
  Copy

getDynamicProperty

• getDynamicProperty(identifier: string): string | number | boolean | Vector3

• Parameters

  • identifier: string

    The property identifier.

  Returns string | number | boolean | Vector3

  Returns the value for the property, or undefined if the property has not been set.

  Remarks

  Returns a property value.

  Throws

  This function can throw errors.

  Example: entityRespawn.ts

  import { Vector3, system, world } from "@minecraft/server";
  
  world.afterEvents.entitySpawn.subscribe((event) => {
      event.entity.setDynamicProperty("spawn_location", event.entity.location); // set location spawn
  });
  
  world.beforeEvents.entityRemove.subscribe((event) => {
      const location = event.removedEntity.getDynamicProperty(
          "spawn_location"
      ) as Vector3; // get location spawn
      const dimension = event.removedEntity.dimension;
      system.run(() => {
          dimension.spawnEntity(event.removedEntity.typeId, location);
      });
  });
  Copy

getDynamicPropertyIds

• getDynamicPropertyIds(): string[]

• Returns string[]

  A string array of the dynamic properties set on this entity.

  Remarks

  Returns the available set of dynamic property identifiers that have been used on this entity.

  Throws

  This function can throw errors.

  Example: displayEntries.ts

  import { Player, system } from "@minecraft/server";
  
  system.afterEvents.scriptEventReceive.subscribe((event) => {
      // Type /scriptevent bp:entries to see this message
      if (event.id === "bp:entries" && event.sourceEntity instanceof Player) {
          event.sourceEntity.sendMessage(
              "Here's your dynamic properties entries:"
          );
  
          // Display all dynamic properties
          for (const id of event.sourceEntity.getDynamicPropertyIds()) {
              event.sourceEntity.sendMessage(
                  `- ${id}: ${event.sourceEntity.getDynamicProperty(id)}`
              );
          }
      }
  });
  Copy

getDynamicPropertyTotalByteCount

• getDynamicPropertyTotalByteCount(): number

• Returns number

  Remarks

  Returns the total size, in bytes, of all the dynamic properties that are currently stored for this entity. This includes the size of both the key and the value. This can be useful for diagnosing performance warning signs - if, for example, an entity has many megabytes of associated dynamic properties, it may be slow to load on various devices.

  Throws

  This function can throw errors.

  Example: displayByteCount.ts

  import { Player, system } from "@minecraft/server";
  
  system.afterEvents.scriptEventReceive.subscribe((event) => {
      // Type /scriptevent dp:size to see this message
      if (event.id === "dp:size" && event.sourceEntity instanceof Player) {
          // Returns the total size, in bytes, of all the dynamic properties that are currently stored for this entity.
          const byteCount = event.sourceEntity.getDynamicPropertyTotalByteCount();
  
          // Send the byte count to the player
          event.sourceEntity.sendMessage(
              `Dynamic Properties Byte Count: ${byteCount}`
          );
      }
  });
  Copy

getEffect

• getEffect(effectType: string | EffectType): Effect

• Parameters

  • effectType: string | EffectType

    The effect identifier.

  Returns Effect

  Effect object for the specified effect, undefined if the effect is not present, or throws an error if the effect does not exist.

  Remarks

  Returns the effect for the specified EffectType on the entity, undefined if the effect is not present, or throws an error if the effect does not exist.

  Throws

  This function can throw errors.

  Example: hasNightVision.js

  import { Player, world } from "@minecraft/server";
  
  /**
   * @param {Player} player
   */
  function hasNightVision(player) {
      const nightVision = player.getEffect("night_vision");
      if (nightVision) {
          return true;
      } else return false;
  }
  
  for (const player of world.getAllPlayers()) {
      if (hasNightVision(player)) {
          player.sendMessage("You have night vision.");
      } else {
          player.sendMessage("You don't have night vision.");
      }
  }
  Copy

getEffects

• getEffects(): Effect[]

• Returns Effect[]

  List of effects.

  Remarks

  Returns a set of effects applied to this entity.

  Throws

  This function can throw errors.

  Example: playerEffects.js

  import { world } from "@minecraft/server";
  
  for (const player of world.getAllPlayers()) {
      for (const effect of player.getEffects()) {
          player.sendMessage(
              `Effect: ${effect.displayName} | Duration: ${effect.duration} | Amplifier: ${effect.amplifier}`
          );
      }
  }
  Copy

getEntitiesFromViewDirection

• getEntitiesFromViewDirection(options?: EntityRaycastOptions): EntityRaycastHit[]

• Parameters

  • Optionaloptions: EntityRaycastOptions

    Additional configuration options for the ray cast.

  Returns EntityRaycastHit[]

  Returns a set of entities from the direction that this entity is looking at.

  Remarks

  Gets the entities that this entity is looking at by performing a ray cast from the view of this entity.

  Throws

  This function can throw errors.

  Example: entityView.ts

  import type { EntityRaycastOptions } from "@minecraft/server";
  import { world } from "@minecraft/server";
  
  // Optional: Configure ray cast options
  const raycastOptions: EntityRaycastOptions = {
      maxDistance: 10, // Set your desired maximum distance
  };
  
  // Perform the ray cast
  
  for (const entity of world.getDimension("overworld").getEntities()) {
      const entitiesInView = entity.getEntitiesFromViewDirection(raycastOptions);
  
      // Log the results
      entitiesInView.forEach((hit) => {
          console.log(`Entity hit at distance ${hit.distance} blocks.`);
          console.log("Entity details:", hit.entity); // You can access properties/methods of the hit entity
      });
  }
  Copy

getHeadLocation

• getHeadLocation(): Vector3

• Returns Vector3

  Returns the current location of the head component of this entity.

  Remarks

  Returns the current location of the head component of this entity.

  Throws

  This function can throw errors.

  Example: freezePlayerCamera.ts

  import { Player } from "@minecraft/server";
  
  function freezePlayerCamera(player: Player) {
      player.camera.setCamera("minecraft:free", {
          location: player.getHeadLocation(),
          rotation: player.getRotation(),
      });
  }
  Copy

getProperty

• getProperty(identifier: string): string | number | boolean

• Parameters

  • identifier: string

    The entity Property identifier.

  Returns string | number | boolean

  Returns the current property value. For enum properties, a string is returned. For float and int properties, a number is returned. For undefined properties, undefined is returned.

  Remarks

  Gets an entity Property value. If the property was set using the setProperty function within the same tick, the updated value will not be reflected until the subsequent tick.

  Throws

  Throws if the entity is invalid.

  Example: getRotationOffset.js

  import { world } from "@minecraft/server";
  
  const entity = world
      .getDimension("overworld")
      .getEntities({ type: "create:dummy" })[0];
  entity.setProperty("create:rotation_offset", 1);
  console.warn(entity.getProperty("create:rotation_offset"));
  Copy

getRotation

• getRotation(): Vector2

• Returns Vector2

  Returns a Vec2 containing the rotation of this entity (in degrees).

  Remarks

  Returns the current rotation component of this entity.

  Throws

  This function can throw errors.

  Example: getRotation.js

  import { world } from "@minecraft/server";
  
  world.beforeEvents.chatSend.subscribe((event) => {
      const message = event.message;
      const player = event.sender;
      if (message === "rotation get") {
          event.cancel = true;
          const rotation = player.getRotation();
          player.sendMessage(`Spawn point location: ${rotation.x} ${rotation.y}`);
      }
  });
  Copy

getTags

• getTags(): string[]

• Returns string[]

  An array containing all tags as strings.

  Remarks

  Returns all tags associated with the entity.

  Throws

  This function can throw errors.

  Example: jaylyTag.js

  import { world } from "@minecraft/server";
  
  for (const entity of world.getDimension("overworld").getEntities()) {
      const tags = entity.getTags();
      const jaylyTag = tags.find((tag) => tag.startsWith("jayly:"));
      if (jaylyTag) {
          world.sendMessage(`${entity.id}: ${jaylyTag}`);
      }
  }
  Copy

getVelocity

• getVelocity(): Vector3

• Returns Vector3

  Returns the current velocity vector of the entity.

  Remarks

  Returns the current velocity vector of the entity.

  Throws

  This function can throw errors.

  Example: getFireworkVelocity.ts

  import { system, DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes } from "@minecraft/vanilla-data";
  
  function getFireworkVelocity(
    log: (message: string, status?: number) => void,
    targetLocation: DimensionLocation
  ) {
    const fireworkRocket = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.FireworksRocket, targetLocation);
  
    system.runTimeout(() => {
      const velocity = fireworkRocket.getVelocity();
  
      log("Velocity of firework is: (x: " + velocity.x + ", y:" + velocity.y + ", z:" + velocity.z + ")");
    }, 5);
  }
  Copy

getViewDirection

• getViewDirection(): Vector3

• Returns Vector3

  Returns the current view direction of the entity.

  Remarks

  Returns the current view direction of the entity.

  Throws

  This function can throw errors.

hasComponent

• hasComponent(componentId: string): boolean

• Parameters

  • componentId: string

    The identifier of the component (e.g., 'minecraft:rideable') to retrieve. If no namespace prefix is specified, 'minecraft:' is assumed.

  Returns boolean

  Returns true if the specified component is present on this entity.

  Remarks

  Returns true if the specified component is present on this entity.

  Example: hasComponents.js

  import { world } from "@minecraft/server";
  
  const entity = world
      .getDimension("overworld")
      .getEntities({ type: "minecraft:villager" })[0];
  entity.hasComponent("tameable");
  entity.hasComponent("inventory");
  entity.hasComponent("addrider");
  entity.hasComponent("is_tamed");
  Copy

hasTag

• hasTag(tag: string): boolean

• Parameters

  • tag: string

    Identifier of the tag to test for.

  Returns boolean

  Returns whether an entity has a particular tag.

  Remarks

  Returns whether an entity has a particular tag.

  Throws

  This function can throw errors.

isValid

• isValid(): boolean

• Returns boolean

  Whether the entity is valid.

  Remarks

  Returns whether the entity can be manipulated by script. A Player is considered valid when it's EntityLifetimeState is set to Loaded.

  Example: tracky.ts

  import { system, world } from "@minecraft/server";
  
  const zombie = world
      .getDimension("overworld")
      .spawnEntity("minecraft:zombie", world.getDefaultSpawnLocation());
  
  const id = system.runInterval(() => {
      if (!zombie.isValid()) {
          system.clearRun(id);
          return;
      }
      const location = zombie.location;
      for (const player of world.getPlayers()) {
          player.sendMessage(
              `Zombie location: (${location.x.toFixed(2)}, ${location.y.toFixed(
                  2
              )}, ${location.z.toFixed(2)})`
          );
      }
  });
  Copy

kill

• kill(): boolean

• Returns boolean

  Returns true if entity can be killed (even if it is already dead), otherwise it returns false.

  Remarks

  Kills this entity. The entity will drop loot as normal.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: tagsQuery.ts

  import { EntityQueryOptions, DimensionLocation } from "@minecraft/server";
  
  function tagsQuery(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();
    }
  }
  Copy

lookAt

• lookAt(targetLocation: Vector3): void
• Beta

  Parameters

  • targetLocation: Vector3

    The target location that this entity should face/look towards.

  Returns void

  Remarks

  Sets the rotation of the entity to face a target location. Both pitch and yaw will be set, if applicable, such as for mobs where the pitch controls the head tilt and the yaw controls the body rotation.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

matches

• matches(options: EntityQueryOptions): boolean

• Parameters

  • options: EntityQueryOptions

    The query to perform the match against.

  Returns boolean

  Returns true if the entity matches the criteria in the passed in EntityQueryOptions, otherwise it returns false.

  Remarks

  Matches the entity against the passed in options. Uses the location of the entity for matching if the location is not specified in the passed in EntityQueryOptions.

  Throws

  Throws if the query options are misconfigured.

  Example: isSpectator.js

  import { GameMode, system, world } from "@minecraft/server";
  system.runInterval(() => {
      for (const player of world.getAllPlayers()) {
          const isSpectating = player.matches({ gameMode: GameMode.spectator });
          if (isSpectating) {
              player.onScreenDisplay.setActionBar("You are spectating");
          }
      }
  });
  Copy

playAnimation

• playAnimation(animationName: string, options?: PlayAnimationOptions): void

• Parameters

  • animationName: string

    The animation identifier. e.g. animation.creeper.swelling
  • Optionaloptions: PlayAnimationOptions

    Additional options to control the playback and transitions of the animation.

  Returns void

  Remarks

  Cause the entity to play the given animation.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

remove

• remove(): void

• Returns void

  Remarks

  Immediately removes the entity from the world. The removed entity will not perform a death animation or drop loot upon removal.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: removeAllEntities.ts

  import { world } from "@minecraft/server";
  
  // Note: You cannot despawn players via entity.remove()
  const entities = world
      .getDimension("overworld")
      .getEntities({ excludeTypes: ["minecraft:player"] });
  
  for (const entity of entities) {
      entity.remove();
  }
  Copy

removeEffect

• removeEffect(effectType: string | EffectType): boolean

• Parameters

  • effectType: string | EffectType

    The effect identifier.

  Returns boolean

  Returns true if the effect has been removed. Returns false if the effect is not found or does not exist.

  Remarks

  Removes the specified EffectType on the entity, or returns false if the effect is not present.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

removeTag

• removeTag(tag: string): boolean

• Parameters

  • tag: string

    Content of the tag to remove.

  Returns boolean

  Returns whether the tag existed on the entity.

  Remarks

  Removes a specified tag from an entity.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: removeAdminTag.ts

  import { world } from "@minecraft/server";
  
  for (const player of world.getAllPlayers()) {
      player.removeTag("admin");
  }
  Copy

resetProperty

• resetProperty(identifier: string): string | number | boolean

• Parameters

  • identifier: string

    The Entity Property identifier.

  Returns string | number | boolean

  Returns the default property value. For enum properties, a string is returned. For float and int properties, a number is returned. For undefined properties, undefined is returned.

  Remarks

  Resets an Entity Property back to its default value, as specified in the Entity's definition. This property change is not applied until the next tick.

  This function can't be called in read-only mode.

  Throws

  Throws if the entity is invalid.

  minecraftcommon.EngineError

  Error

runCommand

• runCommand(commandString: string): CommandResult

• Parameters

  • commandString: string

    The command string. Note: This should not include a leading forward slash.

  Returns CommandResult

  A command result containing whether the command was successful.

  Remarks

  Runs a synchronous command on the entity.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  CommandError

  Error

  Example: sayCommand.js

  import { world } from "@minecraft/server";
  
  world.afterEvents.entityDie.subscribe((event) => {
      event.deadEntity.runCommand("say I am dead!");
  });
  Copy

runCommandAsync

• runCommandAsync(commandString: string): Promise<CommandResult>

• Parameters

  • commandString: string

    Command to run. Note that command strings should not start with slash.

  Returns Promise<CommandResult>

  For commands that return data, returns a JSON structure with command response values.

  Remarks

  Runs a particular command asynchronously from the context of this entity. Note that there is a maximum queue of 128 asynchronous commands that can be run in a given tick.

  Throws

  This function can throw errors.

  Example: sayCommand.js

  import { world } from "@minecraft/server";
  
  world.beforeEvents.explosion.subscribe((event) => {
      event.source?.runCommandAsync("say I exploded!");
  });
  Copy

setDynamicProperty

• setDynamicProperty(
      identifier: string,
      value?: string | number | boolean | Vector3,
  ): void

• Parameters

  • identifier: string

    The property identifier.
  • Optionalvalue: string | number | boolean | Vector3

    Data value of the property to set.

  Returns void

  Remarks

  Sets a specified property to a value.

  Throws

  This function can throw errors.

  Example: entityRespawn.ts

  import { Vector3, system, world } from "@minecraft/server";
  
  world.afterEvents.entitySpawn.subscribe((event) => {
      event.entity.setDynamicProperty("spawn_location", event.entity.location); // set location spawn
  });
  
  world.beforeEvents.entityRemove.subscribe((event) => {
      const location = event.removedEntity.getDynamicProperty(
          "spawn_location"
      ) as Vector3; // get location spawn
      const dimension = event.removedEntity.dimension;
      system.run(() => {
          dimension.spawnEntity(event.removedEntity.typeId, location);
      });
  });
  Copy

setOnFire

• setOnFire(seconds: number, useEffects?: boolean): boolean

• Parameters

  • seconds: number

    Length of time to set the entity on fire.
  • OptionaluseEffects: boolean

    Whether side-effects should be applied (e.g. thawing freeze) and other conditions such as rain or fire protection should be taken into consideration.

  Returns boolean

  Whether the entity was set on fire. This can fail if seconds is less than or equal to zero, the entity is wet or the entity is immune to fire.

  Remarks

  Sets an entity on fire (if it is not in water or rain). Note that you can call getComponent('minecraft:onfire') and, if present, the entity is on fire.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: setOnFire.ts

  import { system, EntityOnFireComponent, EntityComponentTypes, DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes } from "@minecraft/vanilla-data";
  
  function setOnFire(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
    const skelly = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Skeleton, targetLocation);
  
    skelly.setOnFire(20, true);
  
    system.runTimeout(() => {
      const onfire = skelly.getComponent(EntityComponentTypes.OnFire) as EntityOnFireComponent;
      log(onfire?.onFireTicksRemaining + " fire ticks remaining.");
  
      skelly.extinguishFire(true);
      log("Never mind. Fire extinguished.");
    }, 20);
  }
  Copy

setProperty

• setProperty(identifier: string, value: string | number | boolean): void

• Parameters

  • identifier: string

    The Entity Property identifier.
  • value: string | number | boolean

    The property value. The provided type must be compatible with the type specified in the entity's definition.

  Returns void

  Remarks

  Sets an Entity Property to the provided value. This property change is not applied until the next tick.

  This function can't be called in read-only mode.

  Throws

  Throws if the entity is invalid. Throws if an invalid identifier is provided. Throws if the provided value type does not match the property type. Throws if the provided value is outside the expected range (int, float properties). Throws if the provided string value does not match the set of accepted enum values (enum properties

  Example: getRotationOffset.js

  import { world } from "@minecraft/server";
  
  const tileEntity = world
      .getDimension("overworld")
      .getEntities({ type: "create:dummy" })[0];
  tileEntity.setProperty("create:rotation_offset", 1);
  console.warn(tileEntity.getProperty("create:rotation_offset"));
  Copy

setRotation

• setRotation(rotation: Vector2): void

• Parameters

  • rotation: Vector2

    The x and y rotation of the entity (in degrees). For most mobs, the x rotation controls the head tilt and the y rotation controls the body rotation.

  Returns void

  Remarks

  Sets the main rotation of the entity.

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

teleport

• teleport(location: Vector3, teleportOptions?: TeleportOptions): void

• Parameters

  • location: Vector3

    New location for the entity.
  • OptionalteleportOptions: TeleportOptions

    Options regarding the teleport operation.

  Returns void

  Remarks

  Teleports the selected entity to a new location

  This function can't be called in read-only mode.

  Throws

  This function can throw errors.

  Example: teleport.ts

  import { system, DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes } from "@minecraft/vanilla-data";
  
  function teleport(targetLocation: DimensionLocation) {
    const cow = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Cow, targetLocation);
  
    system.runTimeout(() => {
      cow.teleport(
        { x: targetLocation.x + 2, y: targetLocation.y + 2, z: targetLocation.z + 2 },
        {
          facingLocation: targetLocation,
        }
      );
    }, 20);
  }
  Copy

  Example: teleportMovement.ts

  import { system, DimensionLocation } from "@minecraft/server";
  import { MinecraftEntityTypes } from "@minecraft/vanilla-data";
  
  function teleportMovement(targetLocation: DimensionLocation) {
    const pig = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.Pig, targetLocation);
  
    let inc = 1;
    const runId = system.runInterval(() => {
      pig.teleport(
        { x: targetLocation.x + inc / 4, y: targetLocation.y + inc / 4, z: targetLocation.z + inc / 4 },
        {
          facingLocation: targetLocation,
        }
      );
  
      if (inc > 100) {
        system.clearRun(runId);
      }
      inc++;
    }, 4);
  }
  Copy

  Example: teleport.js

  import { system, world } from "@minecraft/server";
  
  system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity, message }) => {
      if (!sourceEntity) return;
  
      if (message === "tp:nether") {
          sourceEntity.teleport(
              { x: 0, y: 0, z: 0 },
              { dimension: world.getDimension("nether") }
          );
      }
  });
  Copy

  Example: teleportFacing.js

  import { system, world } from "@minecraft/server";
  
  system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity, message }) => {
      if (!sourceEntity) return;
  
      if (message === "tp:nether") {
          sourceEntity.teleport(
              { x: 0, y: 0, z: 0 },
              {
                  dimension: world.getDimension("nether"),
                  facingLocation: { x: 100, y: 100, z: 100 },
              }
          );
      }
  });
  Copy