BetaReadonly BetaafterReadonly BetabeforeReadonly BetacurrentReadonly BetaisReadonly BetaserverBetaThe job ID returned from System.runJob.
Cancels the execution of a job queued via System.runJob.
This function can be called in early-execution mode.
BetaCancels the execution of a function run that was previously scheduled via System.run.
This function can be called in early-execution mode.
BetaFunction callback to run at the next game tick.
An opaque identifier that can be used with the clearRun
function to cancel the execution of this run.
Runs a specified function at the next available future time. This is frequently used to implement delayed behaviors and game loops. When run within the context of an event handler, this will generally run the code at the end of the same tick where the event occurred. When run in other code (a system.run callout), this will run the function in the next tick. Note, however, that depending on load on the system, running in the same or next tick is not guaranteed.
This function can be called in early-execution mode.
BetaFunctional code that will run when this interval occurs.
OptionaltickInterval: numberAn interval of every N ticks that the callback will be called upon.
An opaque handle that can be used with the clearRun method to stop the run of this function on an interval.
import { world, system, DimensionLocation } from "@minecraft/server";
function every30Seconds(targetLocation: DimensionLocation) {
const intervalRunIdentifier = Math.floor(Math.random() * 10000);
system.runInterval(() => {
world.sendMessage("This is an interval run " + intervalRunIdentifier + " sending a message every 30 seconds.");
}, 600);
}
BetaThe instance of the generator to run.
An opaque handle that can be used with System.clearJob to stop the run of this generator.
Queues a generator to run until completion. The generator will be given a time slice each tick, and will be run until it yields or completes.
This function can be called in early-execution mode.
import { system, BlockPermutation, DimensionLocation } from "@minecraft/server";
function cubeGenerator(targetLocation: DimensionLocation) {
const blockPerm = BlockPermutation.resolve("minecraft:cobblestone");
system.runJob(blockPlacingGenerator(blockPerm, targetLocation, 15));
}
function* blockPlacingGenerator(blockPerm: BlockPermutation, startingLocation: DimensionLocation, size: number) {
for (let x = startingLocation.x; x < startingLocation.x + size; x++) {
for (let y = startingLocation.y; y < startingLocation.y + size; y++) {
for (let z = startingLocation.z; z < startingLocation.z + size; z++) {
const block = startingLocation.dimension.getBlock({ x: x, y: y, z: z });
if (block) {
block.setPermutation(blockPerm);
}
yield;
}
}
}
}
BetaFunctional code that will run when this timeout occurs.
OptionaltickDelay: numberAmount of time, in ticks, before the interval will be called.
An opaque handle that can be used with the clearRun method to stop the run of this function on an interval.
BetaIdentifier of the message to send. This is custom and dependent on the kinds of behavior packs and content you may have installed within the world.
Data component of the message to send. This is custom and dependent on the kinds of behavior packs and content you may have installed within the world. Message may not exceed 2048 characters in length.
BetaThe amount of ticks to wait. Minimum value is 1.
A promise that is resolved when the specified amount of ticks have occurred.
A class that provides system-level events and functions.