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

    Class WorldAfterEvents

    Contains a set of events that are available across the scope of the World.

    Index

    Properties

    blockExplode buttonPush chatSend dataDrivenEntityTriggerEvent effectAdd entityDie entityHealthChanged entityHitBlock entityHitEntity entityHurt entityLoad entityRemove entitySpawn explosion itemCompleteUse itemDefinitionEvent itemReleaseUse itemStartUse itemStartUseOn itemStopUse itemStopUseOn itemUse itemUseOn leverAction messageReceive pistonActivate playerBreakBlock playerJoin playerLeave playerPlaceBlock playerSpawn pressurePlatePop pressurePlatePush projectileHitBlock projectileHitEntity targetBlockHit tripWireTrip weatherChange worldInitialize

    Properties

    blockExplode: BlockExplodeAfterEventSignal

    This event fires for each BlockLocation destroyed by an explosion. It is fired after the blocks have already been destroyed.

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

    world.afterEvents.blockExplode.subscribe((event: BlockExplodeAfterEvent) => {
        console.log("Block:", event.block);
        console.log("Dimension:", event.dimension);
        console.log("Exploded Block Permutation:", event.explodedBlockPermutation);
        console.log("Source:", event.source);

        // set block back
        event.block.setPermutation(event.explodedBlockPermutation);
    });
    buttonPush: ButtonPushAfterEventSignal

    This event fires when a button is pushed.

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

    world.afterEvents.buttonPush.subscribe((event) => {
        console.log("Button: ", event.block.typeId);
        console.log("Dimension: ", event.dimension.id);
        console.log("Source: ", event.source.typeId);
    });
    chatSend: ChatSendAfterEventSignal

    This event is triggered after a chat message has been broadcast or sent to players.

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

    const chatObjective =
        world.scoreboard.getObjective("chat") ??
        world.scoreboard.addObjective("chat", "chat");

    world.afterEvents.chatSend.subscribe((event) => {
        const { sender } = event;

        const score = chatObjective.hasParticipant(sender)
            ? chatObjective.getScore(sender.scoreboardIdentity)
            : 0;
        chatObjective.setScore(sender, score + 1);
    });
    dataDrivenEntityTriggerEvent: DataDrivenEntityTriggerAfterEventSignal

    This event is fired when an entity event has been triggered that will update the component definition state of an entity.

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

    const eventId = "minecraft:entity_spawned";

    system.runInterval(() => {
        for (let player of world.getAllPlayers()) {
            let [entityRaycaseHit] = player.getEntitiesFromViewDirection({
                maxDistance: 150,
            });
            if (!entityRaycaseHit) continue;
            let entity = entityRaycaseHit.entity;

            if (entity?.typeId === "minecraft:sheep") {
                listenTo(entity);
                entity.triggerEvent(eventId);
            }
        }
    });

    function listenTo(entity: Entity) {
        const callback = world.afterEvents.dataDrivenEntityTriggerEvent.subscribe(
            (data) => {
                world.afterEvents.dataDrivenEntityTriggerEvent.unsubscribe(
                    callback
                );

                data.getModifiers().forEach((modifier) => {
                    console.log(
                        "ComponentGroupsToAdd:",
                        modifier.getComponentGroupsToAdd()
                    );
                    console.log(
                        "ComponentGroupsToRemove:",
                        modifier.getComponentGroupsToRemove()
                    );
                    console.log("Triggers:", modifier.getTriggers());
                });
            },
            { entities: [entity], eventTypes: [eventId] }
        );
    }
    effectAdd: EffectAddAfterEventSignal

    This event fires when an effect, like poisoning, is added to an entity.

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

    const effectAddSubscription = world.afterEvents.effectAdd.subscribe(
        (event) => {
            console.log("Effect:", event.effect);
            console.log("Effect State:", event.effectState);
            console.log("Entity:", event.entity);

            // Your custom handling for the effect added event
            // Example: Notify players, update UI, etc.
        },
        {
            // Optionally provide EntityEventOptions to filter entities or entity types
            entities: [],
            entityTypes: ["minecraft:creeper", "minecraft:player"], // Array of entity type IDs
        }
    );

    // Later, you can unsubscribe when needed
    world.afterEvents.effectAdd.unsubscribe(effectAddSubscription);
    entityDie: EntityDieAfterEventSignal

    This event fires when an entity dies.

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

    world.afterEvents.entityDie.subscribe((event) => {
        world.sendMessage(
            `${event.deadEntity.typeId} died from ${event.damageSource}!`
        );
    });
    entityHealthChanged: EntityHealthChangedAfterEventSignal

    This event fires when entity health changes in any degree.

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

    const healthChangedSubscription =
        world.afterEvents.entityHealthChanged.subscribe(
            (event) => {
                console.log("Entity:", event.entity);
                console.log("Old Health:", event.oldValue);
                console.log("New Health:", event.newValue);

                // Your custom handling for entity health change event
                // Example: Display a message, update UI, etc.
            },
            {
                // Optionally provide EntityEventOptions to filter entities or entity types
                entities: [],
                entityTypes: ["minecraft:player", "minecraft:zombie"], // Array of entity type IDs
            }
        );

    // Later, you can unsubscribe when needed
    world.afterEvents.entityHealthChanged.unsubscribe(healthChangedSubscription);
    entityHitBlock: EntityHitBlockAfterEventSignal

    This event fires when an entity hits (that is, melee attacks) a block.

    import { world } from "@minecraft/server";
    world.afterEvents.entityHitEntity.subscribe((event) => {
        const location1 = event.damagingEntity.location;
        const location2 = event.hitEntity.location;

        const distance = Math.pow(
            Math.pow(location2.x - location1.x, 2) +
                Math.pow(location2.y - location1.y, 2) +
                Math.pow(location2.z - location1.z, 2),
            0.5
        );

        console.log("Distance: " + distance + " blocks");
    });
    entityHitEntity: EntityHitEntityAfterEventSignal

    This event fires when an entity hits (that is, melee attacks) another entity.

    import { world } from "@minecraft/server";
    world.afterEvents.entityHitBlock.subscribe((event) => {
        const location1 = event.damagingEntity.location;
        const location2 = event.hitBlock.location;

        const distance = Math.pow(
            Math.pow(location2.x - location1.x, 2) +
                Math.pow(location2.y - location1.y, 2) +
                Math.pow(location2.z - location1.z, 2),
            0.5
        );

        console.log("Distance: " + distance + " blocks");
    });
    entityHurt: EntityHurtAfterEventSignal

    This event fires when an entity is hurt (takes damage).

    import { Player, world } from "@minecraft/server";
    world.afterEvents.entityHurt.subscribe((event) => {
        if (event.hurtEntity instanceof Player) {
            event.hurtEntity.sendMessage(
                "You were hurt from " + event.damageSource.cause + "!"
            );
        }
    });
    entityLoad: EntityLoadAfterEventSignal

    Fires when an entity is loaded.

    // Subscribe to the EntityLoadAfterEvent
    const entityLoadSubscription = world.afterEvents.entityLoad.subscribe(
        (event: EntityLoadAfterEvent) => {
            // Handle the entity load event
            console.log(`Entity loaded: ${event.entity.typeId}`);
        }
    );

    // ... Later in your code, when you want to unsubscribe
    world.afterEvents.entityLoad.unsubscribe(entityLoadSubscription);
    entityRemove: EntityRemoveAfterEventSignal

    Fires when an entity is removed (for example, potentially unloaded, or removed after being killed).

    entitySpawn: EntitySpawnAfterEventSignal

    This event fires when an entity is spawned.

    explosion: ExplosionAfterEventSignal

    This event is fired after an explosion occurs.

    // Subscribe to the ExplosionAfterEvent
    const explosionSubscription = world.afterEvents.explosion.subscribe(
        (event: ExplosionAfterEvent) => {
            console.log(`Explosion occurred in dimension ${event.dimension.id}`);

            if (event.source) {
                console.log(`Explosion source: ${event.source.typeId}`);
            } else {
                console.log(`Explosion source: None`);
            }

            const impactedBlocks = event.getImpactedBlocks();
            console.log(`Impacted blocks: ${JSON.stringify(impactedBlocks)}`);
        }
    );

    // ... Later in your code, when you want to unsubscribe
    world.afterEvents.explosion.unsubscribe(explosionSubscription);
    itemCompleteUse: ItemCompleteUseAfterEventSignal

    This event fires when a chargeable item completes charging.

    itemDefinitionEvent: ItemDefinitionAfterEventSignal

    For custom items, this event is triggered when the fundamental set of defined components for the item change. Note that this event is only fired for custom data-driven items.

    itemReleaseUse: ItemReleaseUseAfterEventSignal

    This event fires when a chargeable item is released from charging.

    itemStartUse: ItemStartUseAfterEventSignal

    This event fires when a chargeable item starts charging.

    itemStartUseOn: ItemStartUseOnAfterEventSignal

    This event fires when a player successfully uses an item or places a block by pressing the Use Item / Place Block button. If multiple blocks are placed, this event will only occur once at the beginning of the block placement. Note: This event cannot be used with Hoe or Axe items.

    itemStopUse: ItemStopUseAfterEventSignal

    This event fires when a chargeable item stops charging.

    itemStopUseOn: ItemStopUseOnAfterEventSignal

    This event fires when a player releases the Use Item / Place Block button after successfully using an item. Note: This event cannot be used with Hoe or Axe items.

    itemUse: ItemUseAfterEventSignal

    This event fires when an item is successfully used by a player.

    itemUseOn: ItemUseOnAfterEventSignal

    This event fires when an item is used on a block by a player.

    leverAction: LeverActionAfterEventSignal

    A lever has been pulled.

    messageReceive: ServerMessageAfterEventSignal

    This event is an internal implementation detail, and is otherwise not currently functional.

    pistonActivate: PistonActivateAfterEventSignal

    This event fires when a piston expands or retracts.

    playerBreakBlock: PlayerBreakBlockAfterEventSignal

    This event fires for a block that is broken by a player.

    playerJoin: PlayerJoinAfterEventSignal

    This event fires when a player joins a world. See also playerSpawn for another related event you can trap for when a player is spawned the first time within a world.

    import { world } from "@minecraft/server";
    world.afterEvents.playerJoin.subscribe(({ playerId, playerName }) => {
        world.sendMessage(
            `Player ${playerName} (${playerId}) has just joined the world.`
        );
    });
    playerLeave: PlayerLeaveAfterEventSignal

    This event fires when a player leaves a world.

    import { world } from "@minecraft/server";
    world.afterEvents.playerLeave.subscribe(({ playerId, playerName }) => {
        world.sendMessage(
            `Player ${playerName} (${playerId}) has just left the world.`
        );
    });
    playerPlaceBlock: PlayerPlaceBlockAfterEventSignal

    This event fires for a block that is placed by a player.

    playerSpawn: PlayerSpawnAfterEventSignal

    This event fires when a player spawns or respawns. Note that an additional flag within this event will tell you whether the player is spawning right after join vs. a respawn.

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

    world.afterEvents.playerSpawn.subscribe((eventData) => {
        let { player, initialSpawn } = eventData;
        if (!initialSpawn) return;

        // This runs when the player joins the game for the first time!
    });
    pressurePlatePop: PressurePlatePopAfterEventSignal

    A pressure plate has popped back up (i.e., there are no entities on the pressure plate.)

    pressurePlatePush: PressurePlatePushAfterEventSignal

    A pressure plate has pushed (at least one entity has moved onto a pressure plate.)

    projectileHitBlock: ProjectileHitBlockAfterEventSignal

    This event fires when a projectile hits a block.

    projectileHitEntity: ProjectileHitEntityAfterEventSignal

    This event fires when a projectile hits an entity.

    targetBlockHit: TargetBlockHitAfterEventSignal

    A target block was hit.

    tripWireTrip: TripWireTripAfterEventSignal

    A trip wire was tripped.

    weatherChange: WeatherChangeAfterEventSignal

    This event will be triggered when the weather changes within Minecraft.

    worldInitialize: WorldInitializeAfterEventSignal

    This event fires when the script environment is initialized on a World. In addition, you can register dynamic properties within the scope of a world Initialize event.

    Settings

    Member Visibility

    On This Page

    Properties