@jsprismarine/prismarine/dist/world/World.d.ts

Dedicated Minecraft Bedrock Edition server written in TypeScript

import { default as GameruleManager } from './GameruleManager';
import { Vector3 } from '../../../math/src/index.ts';
import { Block, Player, Server, Service } from '../';
import { Entity } from '../entity/Entity';
import { Item } from '../item/Item';
import { WorldEvent } from '../network/packet/WorldEventPacket';
import { Generator } from './Generator';
import { default as Chunk } from './chunk/Chunk';
import { default as BaseProvider } from './providers/BaseProvider';
export interface WorldData {
    name: string;
    path: string;
    server: Server;
    provider: BaseProvider;
    seed: number;
    generator: Generator;
    config?: any;
}
export interface LevelData {
    spawn: {
        x: number;
        y: number;
        z: number;
    } | undefined;
    gameRules: Array<[string, any]>;
    entities: Array<{
        uuid: string;
        type: string;
        position: {
            x: number;
            y: number;
            z: number;
        };
    }>;
}
export interface WorldPlayerData {
    gamemode: string;
    position: {
        x: number;
        y: number;
        z: number;
        pitch: number;
        yaw: number;
        headYaw: number;
    };
}
export declare class World implements Service {
    private readonly uuid;
    private name;
    private readonly entities;
    private readonly chunks;
    private readonly gameruleManager;
    private currentTick;
    private readonly provider;
    private readonly server;
    private readonly seed;
    private readonly generator;
    private readonly config;
    private spawn;
    constructor({ name, server, provider, seed, generator, config }: WorldData);
    /**
     * On enable hook.
     * @group Lifecycle
     */
    enable(): Promise<void>;
    /**
     * On disable hook.
     * @group Lifecycle
     */
    disable(): Promise<void>;
    getGenerator(): Generator;
    /**
     * Called every tick.
     *
     * @param tick
     */
    update(tick: number): Promise<void>;
    /**
     * Returns a block instance in the given world position.
     * @param {number} x - block x
     * @param {number} y - block y
     * @param {number} z - block z
     * @param {number} [layer=0] - block storage layer (0 for blocks, 1 for liquids)
     */
    getBlock(x: number, y: number, z: number, layer?: number): Promise<Block>;
    /**
     * Returns the chunk in the specifies x and z, if the chunk doesn't exists
     * it is generated.
     */
    getChunk(cx: number, cz: number): Promise<Chunk>;
    /**
     * Loads a chunk in a given x and z and returns its.
     * @param {number} x - x coordinate.
     * @param {number} z - z coordinate.
     */
    loadChunk(x: number, z: number, _ignoreWarn?: boolean): Promise<Chunk>;
    /**
     * Sends a world event packet to all the viewers in the position chunk.
     * @param {Vector3} position - world position.
     * @param {number} event - event identifier.
     * @param {number} data - event data.
     */
    sendWorldEvent(position: Vector3 | null, event: WorldEvent, data: number): Promise<void>;
    /**
     * Returns a chunk from a block position's x and z coordinates.
     */
    getChunkAt(x: Vector3): Promise<Chunk>;
    getChunkAt(x: number, z: number): Promise<Chunk>;
    /**
     * Returns the world default spawn position.
     */
    getSpawnPosition(): Promise<Vector3>;
    /**
     * Set the world's spawn position.
     * @param {Vector3} pos - The position.
     */
    setSpawnPosition(pos: Vector3): void;
    useItemOn(itemInHand: Item | Block | null, blockPosition: Vector3, face: number, clickPosition: Vector3, player: Player): Promise<void>;
    /**
     * Sends the current time to all players in the world.
     */
    sendTime(): Promise<void>;
    /**
     * Adds an entity to the level.
     * @param {Entity} entity - The entity to add.
     */
    addEntity(entity: Entity): Promise<void>;
    /**
     * Removes an entity from the level.
     * @param {Entity} entity - The entity to remove.
     */
    removeEntity(entity: Entity): Promise<void>;
    /**
     * Get all entities in this world.
     * @returns {Entity[]} the entities.
     */
    getEntities(): Entity[];
    /**
     * Get all players in this world.
     * @returns {Player[]} the players.
     */
    getPlayers(): Player[];
    /**
     * Saves changed chunks into disk.
     */
    saveChunks(): Promise<void>;
    save(): Promise<void>;
    getGameruleManager(): GameruleManager;
    getTicks(): number;
    setTicks(tick: number): void;
    getProvider(): any;
    getUUID(): string;
    getName(): string;
    getFormattedName(): string;
    getSeed(): number;
    private getLevelData;
    saveLevelData(): Promise<void>;
    /**
     * Get the player data for a player.
     * @param {Player} player - The player to get the data for.
     * @returns {Promise<WorldPlayerData>} The player data.
     */
    getPlayerData(player: Player): Promise<Partial<WorldPlayerData>>;
    savePlayerData(player: Player): Promise<void>;
    /**
     * @returns {Server} The server instance.
     */
    getServer(): Server;
}
//# sourceMappingURL=World.d.ts.map