@jsprismarine/prismarine
Version:
Dedicated Minecraft Bedrock Edition server written in TypeScript
467 lines (463 loc) • 58.5 kB
JavaScript
'use strict';
Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
const raknet = require('@jsprismarine/raknet');
const Console = require('./Console.cjs.cjs');
const SessionManager = require('./SessionManager.cjs.cjs');
const ban_BanManager = require('./ban/BanManager.cjs.cjs');
const block_BlockManager = require('./block/BlockManager.cjs.cjs');
const block_BlockMappings = require('./block/BlockMappings.cjs.cjs');
const chat_ChatManager = require('./chat/ChatManager.cjs.cjs');
const command_CommandManager = require('./command/CommandManager.cjs.cjs');
const events_EventEmitter = require('./events/EventEmitter.cjs.cjs');
require('@jsprismarine/math');
const events_raknet_RaknetConnectEvent = require('./events/raknet/RaknetConnectEvent.cjs.cjs');
const events_raknet_RaknetDisconnectEvent = require('./events/raknet/RaknetDisconnectEvent.cjs.cjs');
const events_raknet_RaknetEncapsulatedPacketEvent = require('./events/raknet/RaknetEncapsulatedPacketEvent.cjs.cjs');
const events_other_TickEvent = require('./events/other/TickEvent.cjs.cjs');
const item_ItemManager = require('./item/ItemManager.cjs.cjs');
const network_ClientConnection = require('./network/ClientConnection.cjs.cjs');
const network_Identifiers = require('./network/Identifiers.cjs.cjs');
const network_PacketRegistry = require('./network/PacketRegistry.cjs.cjs');
const network_packet_BatchPacket = require('./network/packet/BatchPacket.cjs.cjs');
const permission_PermissionManager = require('./permission/PermissionManager.cjs.cjs');
const query_QueryManager = require('./query/QueryManager.cjs.cjs');
const utils_Timer = require('./utils/Timer.cjs.cjs');
const world_WorldManager = require('./world/WorldManager.cjs.cjs');
const _package = require('./package.json.cjs.cjs');
class Server extends events_EventEmitter.EventEmitter {
raknet;
logger;
config;
console;
packetRegistry;
sessionManager = new SessionManager.default();
commandManager;
worldManager;
itemManager;
blockManager;
queryManager;
chatManager;
permissionManager;
banManager;
/**
* If the server is stopping.
* @internal
*/
stopping = false;
/**
* The current ticker timer.
* @internal
*/
tickerTimer;
/**
* The current TPS.
* @internal
*/
tps = 20;
/**
* The current tick.
* @internal
*/
currentTick = 0n;
/**
* If the server is headless.
* @internal
*/
headless;
// TODO: Move this somewhere else.
static MINECRAFT_TICK_TIME_MS = 1e3 / 20;
/**
* Creates a new server instance.
* @param {object} options - The options.
* @param {LoggerBuilder} options.logger - The logger.
* @param {Config} options.config - The config.
* @returns {Server} The server instance.
*/
constructor({ logger, config, headless = false }) {
super();
this.headless = headless;
logger.info(
`Starting JSPrismarine server version §ev${_package.version}§r for Minecraft: Bedrock Edition ${network_Identifiers.default.MinecraftVersions.at(-1)} (protocol version §e${network_Identifiers.default.Protocol}§r)`
);
this.logger = logger;
this.config = config;
this.packetRegistry = new network_PacketRegistry.default(this);
this.itemManager = new item_ItemManager.default(this);
this.blockManager = new block_BlockManager.default(this);
this.worldManager = new world_WorldManager.default(this);
if (!this.headless) this.console = new Console.default(this);
this.commandManager = new command_CommandManager.CommandManager(this);
this.queryManager = new query_QueryManager.QueryManager(this);
this.chatManager = new chat_ChatManager.ChatManager(this);
this.permissionManager = new permission_PermissionManager.PermissionManager(this);
this.banManager = new ban_BanManager.default(this);
}
/**
* Enables the server.
* @returns {Promise<void>} A promise that resolves when the server is enabled.
* @internal
*/
async enable() {
await block_BlockMappings.BlockMappings.initMappings(this);
await this.config.enable();
await this.console?.enable();
await this.logger.enable();
await this.permissionManager.enable();
await this.packetRegistry.enable();
await this.itemManager.enable();
await this.blockManager.enable();
await this.banManager.enable();
await this.commandManager.enable();
await this.worldManager.enable();
this.logger.setConsole(this.console);
}
/**
* Disables the server.
* @returns {Promise<void>} A promise that resolves when the server is disabled.
* @internal
*/
async disable() {
await this.worldManager.disable();
await this.commandManager.disable();
await this.banManager.disable();
await this.blockManager.disable();
await this.itemManager.disable();
await this.permissionManager.disable();
await this.packetRegistry.disable();
await this.config.disable();
await this.logger.disable();
block_BlockMappings.BlockMappings.reset();
}
getMetadata() {
if (!this.raknet) throw new Error("Server is not started");
return this.raknet.serverName;
}
/**
* Reloads the server.
* @returns {Promise<void>} A promise that resolves when the server is reloaded.
* @remarks This method is equivalent to calling {@link Server#disable} and {@link Server#enable}.
* @remarks This method and functionality is unsupported and should ideally be completely avoided.
*/
async reload() {
await this.disable();
await this.enable();
}
/**
* Starts the server.
* @param {string} [serverIp='0.0.0.0'] - The server IP.
* @param {number} [port=19132] - The server port.
* @returns {Promise<void>} A promise that resolves when the server is started.
*/
async bootstrap(serverIp = "0.0.0.0", port = 19132) {
await this.enable();
this.raknet = new raknet.RakNetListener(
this.getConfig().getMaxPlayers(),
this.getConfig().getOnlineMode(),
new raknet.ServerName(this),
this.getLogger()
);
this.raknet.start(serverIp, port);
this.raknet.on("openConnection", async (session) => {
const event = new events_raknet_RaknetConnectEvent.default(session);
await this.emit("raknetConnect", event);
if (event.isCancelled()) {
session.disconnect();
return;
}
const token = session.getAddress().toToken();
if (this.sessionManager.has(token)) {
this.logger.error(`Another client with token (${token}) is already connected!`);
session.disconnect("Already connected from another location");
return;
}
const timer = new utils_Timer.default();
this.logger.debug(`${token} is attempting to connect`);
this.sessionManager.add(token, new network_ClientConnection.default(session, this.logger));
this.logger.verbose(`New connection handling took §e${timer.stop()} ms§r`);
});
this.raknet.on("closeConnection", async (inetAddr, reason) => {
const event = new events_raknet_RaknetDisconnectEvent.default(inetAddr, reason);
await this.emit("raknetDisconnect", event);
const time = Date.now();
const token = inetAddr.toToken();
const session = this.sessionManager.get(token);
if (!session) {
this.logger.debug(`Cannot remove connection from non-existing player (${token})`);
return;
}
await session.closePlayerSession();
this.sessionManager.remove(token);
this.logger.debug(`${token} disconnected due to ${reason}`);
this.logger.debug(`Player destruction took about ${Date.now() - time} ms`);
});
this.raknet.on("encapsulated", async (packet, inetAddr) => {
const event = new events_raknet_RaknetEncapsulatedPacketEvent.default(inetAddr, packet);
await this.emit("raknetEncapsulatedPacket", event);
let connection;
if ((connection = this.sessionManager.get(inetAddr.toToken()) ?? null) === null) {
this.logger.error(`Got a packet from a closed connection (${inetAddr.toToken()})`);
return;
}
try {
const batched = new network_packet_BatchPacket.default(packet.content);
batched.compressed = connection.hasCompression;
for (const buf of await batched.asyncDecode()) {
const pid = buf[0];
if (!this.packetRegistry.getPackets().has(pid)) {
this.logger.warn(`Packet 0x${pid.toString(16)} isn't implemented`);
continue;
}
const packet2 = new (this.packetRegistry.getPackets().get(pid))(buf);
try {
packet2.decode();
} catch (error) {
this.logger.error(error);
this.logger.error(`Error while decoding packet: ${packet2.constructor.name}: ${error}`);
continue;
}
try {
const handler = this.packetRegistry.getHandler(pid);
this.logger.silly(`Received §b${packet2.constructor.name}§r packet`);
await handler.handle(packet2, this, connection.getPlayerSession() ?? connection);
} catch (error) {
this.logger.error(`Handler error ${packet2.constructor.name}-handler: (${error})`);
this.logger.error(error);
}
}
} catch (error) {
this.logger.error(error);
}
});
this.raknet.on("raw", async (buffer, inetAddr) => {
if (!this.config.getEnableQuery()) return;
try {
await this.queryManager.onRaw(buffer, inetAddr);
} catch (error) {
this.logger.verbose(`QueryManager encountered an error`);
this.logger.error(error);
}
});
if (this.config.getEnableTicking()) {
let startTime = Date.now();
let tpsStartTime = Date.now();
let lastTickTime = Date.now();
let tpsStartTick = this.getTick();
const tick = async () => {
if (this.stopping) return;
const event = new events_other_TickEvent.default(this.getTick());
void this.emit("tick", event);
const ticksPerSecond = 1e3 / Server.MINECRAFT_TICK_TIME_MS;
await Promise.all(this.worldManager.getWorlds().map((world) => world.update(event.getTick())));
if (this.config.getEnableProcessTitle() && this.getTick() % ticksPerSecond === 0 && !this.headless) {
process.title = `TPS: ${this.getTPS().toFixed(2)} | Tick: ${this.getTick()} | ${process.title.split("| ").at(-1)}`;
}
this.currentTick++;
const endTime = Date.now();
const elapsedTime = endTime - startTime;
const expectedElapsedTime = this.getTick() * Server.MINECRAFT_TICK_TIME_MS;
const executionTime = endTime - lastTickTime;
let sleepTime = Server.MINECRAFT_TICK_TIME_MS - executionTime;
if (elapsedTime < expectedElapsedTime) {
sleepTime += expectedElapsedTime - elapsedTime;
} else if (elapsedTime > expectedElapsedTime) {
sleepTime = Math.max(0, sleepTime - (elapsedTime - expectedElapsedTime));
}
if (tpsStartTime !== endTime) {
this.tps = (this.getTick() - tpsStartTick) * 1e3 / (endTime - tpsStartTime);
}
if (endTime - tpsStartTime >= 1e3) {
tpsStartTick = this.getTick();
tpsStartTime = endTime;
}
this.tps = Math.min(this.tps, 20);
lastTickTime = endTime;
this.tickerTimer = setTimeout(tick, sleepTime);
this.tickerTimer.unref();
};
void tick();
}
this.logger.info(`JSPrismarine is now listening on port §b${port}`);
}
/**
* Kills the server asynchronously.
* @param {object} [options] - The options.
* @param {boolean} [options.crash] - If the server should crash.
* @param {boolean} [options.stayAlive] - If we should let the process stay alive.
* @returns {Promise<void>} A promise that resolves when the server is killed.
*/
async shutdown(options) {
if (this.stopping) return;
this.stopping = true;
this.logger.info("Stopping server", "Server/kill");
await this.console?.disable();
clearInterval(this.tickerTimer);
try {
await this.sessionManager.kickAllPlayers("Server closed.");
await this.disable();
this.raknet?.kill();
this.removeAllListeners();
console.debug("Server stopped, Goodbye!\n");
if (!options?.stayAlive) process.exit(options?.crash ? 1 : 0);
} catch (error) {
console.error(error);
if (!options?.stayAlive) process.exit(1);
}
}
async broadcastPacket(dataPacket) {
for (const onlinePlayer of this.sessionManager.getAllPlayers()) {
await onlinePlayer.getNetworkSession().getConnection().sendDataPacket(dataPacket);
}
}
/**
* Returns the server version.
* @returns {string} The server version.
* @example
* ```typescript
* console.log(server.getVersion());
* ```
*/
getVersion() {
return _package.version;
}
/**
* Returns the identifiers.
* @returns {Identifiers} The identifiers.
*/
getIdentifiers() {
return network_Identifiers.default;
}
/**
* Returns the query manager.
* @returns {QueryManager} The query manager.
*/
getQueryManager() {
return this.queryManager;
}
/**
* Returns the command manager.
* @returns {CommandManager} The command manager.
*/
getCommandManager() {
return this.commandManager;
}
/**
* Returns the player manager.
* @returns {SessionManager} The player manager.
*/
getSessionManager() {
return this.sessionManager;
}
/**
* Returns the world manager.
* @returns {WorldManager} The world manager.
*/
getWorldManager() {
return this.worldManager;
}
/**
* Returns the item manager.
* @returns {ItemManager} The item manager.
*/
getItemManager() {
return this.itemManager;
}
/**
* Returns the block manager.
* @returns {BlockManager} The block manager.
*/
getBlockManager() {
return this.blockManager;
}
/**
* Returns the logger.
* @returns {LoggerBuilder} The logger.
* @example
* ```typescript
* // Normal log:
* server.getLogger().info('Hello, world!');
* // Debug log:
* server.getLogger().debug('Hello, world!');
* // Error log:
* server.getLogger().error(new Error('Hello World'));
* ```
*/
getLogger() {
return this.logger;
}
/**
* Returns the packet registry.
* @returns {PacketRegistry} The packet registry.
*/
getPacketRegistry() {
return this.packetRegistry;
}
/**
* Returns the raknet instance.
* @returns {RakNetListener | undefined} The raknet instance.
*/
getRaknet() {
return this.raknet;
}
/**
* Returns the chat manager.
* @returns {ChatManager} The chat manager.
*/
getChatManager() {
return this.chatManager;
}
/**
* Returns the config.
* @returns {Config} The config.
* @example
* ```typescript
* console.log(server.getConfig().getMaxPlayers()); // 20
* ```
*/
getConfig() {
return this.config;
}
/**
* Returns the console instance.
* @returns {Console | undefined} The console instance.
*/
getConsole() {
return this.console;
}
/**
* Returns the permission manager.
* @returns {PermissionManager} The permission manager.
*/
getPermissionManager() {
return this.permissionManager;
}
/**
* Returns the ban manager.
* @returns {BanManager} The ban manager.
*/
getBanManager() {
return this.banManager;
}
/**
* Returns this Prismarine instance.
* @returns {Server} The Prismarine instance.
*/
getServer() {
return this;
}
/**
* Returns the current Tick.
* @returns {number} The current Tick.
*/
getTick() {
return Number(this.currentTick);
}
/**
* Returns the current TPS.
* @returns {number} The current TPS.
*/
getTPS() {
return Number.parseFloat(this.tps.toFixed(2));
}
}
exports.default = Server;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"Server.cjs.cjs","sources":["../src/Server.ts"],"sourcesContent":["import { RakNetListener, ServerName } from '@jsprismarine/raknet';\nimport Console from './Console';\nimport SessionManager from './SessionManager';\nimport BanManager from './ban/BanManager';\nimport BlockManager from './block/BlockManager';\nimport { BlockMappings } from './block/BlockMappings';\nimport { ChatManager } from './chat/ChatManager';\nimport { CommandManager } from './command/CommandManager';\nimport { EventEmitter } from './events/EventEmitter';\nimport { TickEvent } from './events/Events';\nimport RaknetConnectEvent from './events/raknet/RaknetConnectEvent';\nimport RaknetDisconnectEvent from './events/raknet/RaknetDisconnectEvent';\nimport RaknetEncapsulatedPacketEvent from './events/raknet/RaknetEncapsulatedPacketEvent';\nimport ItemManager from './item/ItemManager';\nimport ClientConnection from './network/ClientConnection';\nimport Identifiers from './network/Identifiers';\nimport PacketRegistry from './network/PacketRegistry';\nimport type { DataPacket } from './network/Packets';\nimport BatchPacket from './network/packet/BatchPacket';\nimport { PermissionManager } from './permission/PermissionManager';\nimport { QueryManager } from './query/QueryManager';\nimport Timer from './utils/Timer';\nimport WorldManager from './world/WorldManager';\n\nimport type { InetAddress, RakNetSession } from '@jsprismarine/raknet';\nimport type { Config } from './config/Config';\n\nimport type { Logger } from '@jsprismarine/logger';\nimport { version } from '../package.json' with { type: 'json' };\n\n/**\n * JSPrismarine's main server class.\n * @public\n */\nexport default class Server extends EventEmitter {\n    private raknet: RakNetListener | undefined;\n    private readonly logger: Logger;\n    private readonly config: Config;\n    private readonly console: Console | undefined;\n    private readonly packetRegistry: PacketRegistry;\n    private readonly sessionManager = new SessionManager();\n    private readonly commandManager: CommandManager;\n    private readonly worldManager: WorldManager;\n    private readonly itemManager: ItemManager;\n    private readonly blockManager: BlockManager;\n    private readonly queryManager: QueryManager;\n    private readonly chatManager: ChatManager;\n    private readonly permissionManager: PermissionManager;\n    private readonly banManager: BanManager;\n\n    /**\n     * If the server is stopping.\n     * @internal\n     */\n    private stopping = false;\n\n    /**\n     * The current ticker timer.\n     * @internal\n     */\n    private tickerTimer: NodeJS.Timeout | undefined;\n\n    /**\n     * The current TPS.\n     * @internal\n     */\n    private tps = 20;\n\n    /**\n     * The current tick.\n     * @internal\n     */\n    private currentTick = 0n;\n\n    /**\n     * If the server is headless.\n     * @internal\n     */\n    private readonly headless: boolean;\n\n    // TODO: Move this somewhere else.\n    private static readonly MINECRAFT_TICK_TIME_MS = 1000 / 20;\n\n    /**\n     * Creates a new server instance.\n     * @param {object} options - The options.\n     * @param {LoggerBuilder} options.logger - The logger.\n     * @param {Config} options.config - The config.\n     * @returns {Server} The server instance.\n     */\n    public constructor({ logger, config, headless = false }: { logger: Logger; config: Config; headless?: boolean }) {\n        super();\n\n        this.headless = headless;\n\n        logger.info(\n            `Starting JSPrismarine server version §ev${version}§r for Minecraft: Bedrock Edition ${Identifiers.MinecraftVersions.at(-1)} (protocol version §e${Identifiers.Protocol}§r)`\n        );\n\n        this.logger = logger;\n        this.config = config;\n        this.packetRegistry = new PacketRegistry(this);\n        this.itemManager = new ItemManager(this);\n        this.blockManager = new BlockManager(this);\n        this.worldManager = new WorldManager(this);\n        if (!this.headless) this.console = new Console(this);\n        this.commandManager = new CommandManager(this);\n        this.queryManager = new QueryManager(this);\n        this.chatManager = new ChatManager(this);\n        this.permissionManager = new PermissionManager(this);\n        this.banManager = new BanManager(this);\n    }\n\n    /**\n     * Enables the server.\n     * @returns {Promise<void>} A promise that resolves when the server is enabled.\n     * @internal\n     */\n    private async enable(): Promise<void> {\n        await BlockMappings.initMappings(this);\n\n        await this.config.enable();\n        await this.console?.enable();\n        await this.logger.enable();\n        await this.permissionManager.enable();\n        await this.packetRegistry.enable();\n        await this.itemManager.enable();\n        await this.blockManager.enable();\n        await this.banManager.enable();\n        await this.commandManager.enable();\n        await this.worldManager.enable();\n\n        this.logger.setConsole(this.console);\n    }\n\n    /**\n     * Disables the server.\n     * @returns {Promise<void>} A promise that resolves when the server is disabled.\n     * @internal\n     */\n    private async disable(): Promise<void> {\n        await this.worldManager.disable();\n        await this.commandManager.disable();\n        await this.banManager.disable();\n        await this.blockManager.disable();\n        await this.itemManager.disable();\n        await this.permissionManager.disable();\n        await this.packetRegistry.disable();\n        await this.config.disable();\n        await this.logger.disable();\n\n        BlockMappings.reset();\n    }\n\n    public getMetadata() {\n        if (!this.raknet) throw new Error('Server is not started');\n        return this.raknet.serverName;\n    }\n\n    /**\n     * Reloads the server.\n     * @returns {Promise<void>} A promise that resolves when the server is reloaded.\n     * @remarks This method is equivalent to calling {@link Server#disable} and {@link Server#enable}.\n     * @remarks This method and functionality is unsupported and should ideally be completely avoided.\n     */\n    public async reload(): Promise<void> {\n        await this.disable();\n        await this.enable();\n    }\n\n    /**\n     * Starts the server.\n     * @param {string} [serverIp='0.0.0.0'] - The server IP.\n     * @param {number} [port=19132] - The server port.\n     * @returns {Promise<void>} A promise that resolves when the server is started.\n     */\n    public async bootstrap(serverIp = '0.0.0.0', port = 19132): Promise<void> {\n        await this.enable();\n\n        this.raknet = new RakNetListener(\n            this.getConfig().getMaxPlayers(),\n            this.getConfig().getOnlineMode(),\n            new ServerName(this),\n            this.getLogger()\n        );\n        this.raknet.start(serverIp, port);\n\n        this.raknet.on('openConnection', async (session: RakNetSession) => {\n            const event = new RaknetConnectEvent(session);\n            await this.emit('raknetConnect', event);\n\n            if (event.isCancelled()) {\n                session.disconnect();\n                return;\n            }\n\n            const token = session.getAddress().toToken();\n            if (this.sessionManager.has(token)) {\n                this.logger.error(`Another client with token (${token}) is already connected!`);\n                session.disconnect('Already connected from another location');\n                return;\n            }\n\n            const timer = new Timer();\n            this.logger.debug(`${token} is attempting to connect`);\n            this.sessionManager.add(token, new ClientConnection(session, this.logger));\n            this.logger.verbose(`New connection handling took §e${timer.stop()} ms§r`);\n        });\n\n        this.raknet.on('closeConnection', async (inetAddr: InetAddress, reason: string) => {\n            const event = new RaknetDisconnectEvent(inetAddr, reason);\n            await this.emit('raknetDisconnect', event);\n\n            const time = Date.now();\n            const token = inetAddr.toToken();\n\n            const session = this.sessionManager.get(token);\n            if (!session) {\n                this.logger.debug(`Cannot remove connection from non-existing player (${token})`);\n                return;\n            }\n\n            await session.closePlayerSession();\n\n            this.sessionManager.remove(token);\n            this.logger.debug(`${token} disconnected due to ${reason}`);\n            this.logger.debug(`Player destruction took about ${Date.now() - time} ms`);\n        });\n\n        this.raknet.on('encapsulated', async (packet: any, inetAddr: InetAddress) => {\n            const event = new RaknetEncapsulatedPacketEvent(inetAddr, packet);\n            await this.emit('raknetEncapsulatedPacket', event);\n\n            let connection: ClientConnection | null;\n            if ((connection = this.sessionManager.get(inetAddr.toToken()) ?? null) === null) {\n                this.logger.error(`Got a packet from a closed connection (${inetAddr.toToken()})`);\n                return;\n            }\n\n            try {\n                // Read batch content and handle them\n                const batched = new BatchPacket(packet.content);\n                batched.compressed = connection.hasCompression;\n\n                // Read all packets inside batch and handle them\n                for (const buf of await batched.asyncDecode()) {\n                    const pid = buf[0]!;\n\n                    if (!this.packetRegistry.getPackets().has(pid)) {\n                        this.logger.warn(`Packet 0x${pid.toString(16)} isn't implemented`);\n                        continue;\n                    }\n\n                    // Get packet from registry\n                    const packet = new (this.packetRegistry.getPackets().get(pid)!)(buf);\n\n                    try {\n                        packet.decode();\n                    } catch (error: unknown) {\n                        this.logger.error(error);\n                        this.logger.error(`Error while decoding packet: ${packet.constructor.name}: ${error}`);\n                        continue;\n                    }\n\n                    try {\n                        const handler = this.packetRegistry.getHandler(pid);\n                        this.logger.silly(`Received §b${packet.constructor.name}§r packet`);\n                        await (handler as any).handle(packet, this, connection.getPlayerSession() ?? connection);\n                    } catch (error: unknown) {\n                        this.logger.error(`Handler error ${packet.constructor.name}-handler: (${error})`);\n                        this.logger.error(error);\n                    }\n                }\n            } catch (error: unknown) {\n                this.logger.error(error);\n            }\n        });\n\n        this.raknet.on('raw', async (buffer: Buffer, inetAddr: InetAddress) => {\n            if (!this.config.getEnableQuery()) return;\n\n            try {\n                await this.queryManager.onRaw(buffer, inetAddr);\n            } catch (error: unknown) {\n                this.logger.verbose(`QueryManager encountered an error`);\n                this.logger.error(error);\n            }\n        });\n\n        if (this.config.getEnableTicking()) {\n            let startTime = Date.now();\n            let tpsStartTime = Date.now();\n            let lastTickTime = Date.now();\n            let tpsStartTick = this.getTick();\n            const tick = async () => {\n                if (this.stopping) return;\n\n                const event = new TickEvent(this.getTick());\n                void this.emit('tick', event);\n\n                const ticksPerSecond = 1000 / Server.MINECRAFT_TICK_TIME_MS;\n\n                // Update all worlds.\n                await Promise.all(this.worldManager.getWorlds().map((world) => world.update(event.getTick())));\n\n                if (this.config.getEnableProcessTitle() && this.getTick() % ticksPerSecond === 0 && !this.headless) {\n                    // Update the process title with TPS and tick.\n                    process.title = `TPS: ${this.getTPS().toFixed(2)} | Tick: ${this.getTick()} | ${process.title.split('| ').at(-1)!}`;\n                }\n\n                this.currentTick++;\n                const endTime = Date.now();\n                const elapsedTime = endTime - startTime;\n                const expectedElapsedTime = this.getTick() * Server.MINECRAFT_TICK_TIME_MS;\n                const executionTime = endTime - lastTickTime;\n\n                // Adjust sleepTime based on execution speed.\n                let sleepTime = Server.MINECRAFT_TICK_TIME_MS - executionTime;\n                if (elapsedTime < expectedElapsedTime) {\n                    // If we're running faster than expected, increase sleepTime.\n                    sleepTime += expectedElapsedTime - elapsedTime;\n                } else if (elapsedTime > expectedElapsedTime) {\n                    // If we're running slower than expected, decrease sleepTime but don't let it go below 0.\n                    sleepTime = Math.max(0, sleepTime - (elapsedTime - expectedElapsedTime));\n                }\n\n                // Calculate tps based on the actual elapsed time since the start of the tick.\n                if (tpsStartTime !== endTime) {\n                    this.tps = ((this.getTick() - tpsStartTick) * 1000) / (endTime - tpsStartTime);\n                }\n\n                if (endTime - tpsStartTime >= 1000) {\n                    tpsStartTick = this.getTick();\n                    tpsStartTime = endTime;\n                }\n\n                this.tps = Math.min(this.tps, 20); // Ensure tps does not exceed 20\n\n                lastTickTime = endTime;\n                this.tickerTimer = setTimeout(tick, sleepTime);\n                this.tickerTimer.unref();\n            };\n\n            // Start ticking\n            void tick();\n        }\n\n        this.logger.info(`JSPrismarine is now listening on port §b${port}`);\n    }\n\n    /**\n     * Kills the server asynchronously.\n     * @param {object} [options] - The options.\n     * @param {boolean} [options.crash] - If the server should crash.\n     * @param {boolean} [options.stayAlive] - If we should let the process stay alive.\n     * @returns {Promise<void>} A promise that resolves when the server is killed.\n     */\n    public async shutdown(options?: { crash?: boolean; stayAlive?: boolean }): Promise<void> {\n        if (this.stopping) return;\n        this.stopping = true;\n\n        this.logger.info('Stopping server', 'Server/kill');\n        await this.console?.disable();\n\n        clearInterval(this.tickerTimer);\n\n        try {\n            // Kick all online players.\n            await this.sessionManager.kickAllPlayers('Server closed.');\n\n            // Disable all managers.\n            await this.disable();\n\n            // `this.raknet` might be undefined if we kill the server really early.\n            this.raknet?.kill();\n\n            // Finally, remove all listeners.\n            this.removeAllListeners();\n\n            // Logger is no longer available.\n            console.debug('Server stopped, Goodbye!\\n');\n\n            if (!options?.stayAlive) process.exit(options?.crash ? 1 : 0);\n        } catch (error: unknown) {\n            console.error(error);\n            if (!options?.stayAlive) process.exit(1);\n        }\n    }\n\n    public async broadcastPacket<T extends DataPacket>(dataPacket: T): Promise<void> {\n        // Maybe i can improve this by using the UDP broadcast, all unconnected clients\n        // will ignore the connected packet probably, but may cause issues.\n        for (const onlinePlayer of this.sessionManager.getAllPlayers()) {\n            await onlinePlayer.getNetworkSession().getConnection().sendDataPacket(dataPacket);\n        }\n    }\n\n    /**\n     * Returns the server version.\n     * @returns {string} The server version.\n     * @example\n     * ```typescript\n     * console.log(server.getVersion());\n     * ```\n     */\n    public getVersion(): string {\n        return version;\n    }\n\n    /**\n     * Returns the identifiers.\n     * @returns {Identifiers} The identifiers.\n     */\n    public getIdentifiers(): typeof Identifiers {\n        return Identifiers;\n    }\n\n    /**\n     * Returns the query manager.\n     * @returns {QueryManager} The query manager.\n     */\n    public getQueryManager(): QueryManager {\n        return this.queryManager;\n    }\n\n    /**\n     * Returns the command manager.\n     * @returns {CommandManager} The command manager.\n     */\n    public getCommandManager(): CommandManager {\n        return this.commandManager;\n    }\n\n    /**\n     * Returns the player manager.\n     * @returns {SessionManager} The player manager.\n     */\n    public getSessionManager(): SessionManager {\n        return this.sessionManager;\n    }\n\n    /**\n     * Returns the world manager.\n     * @returns {WorldManager} The world manager.\n     */\n    public getWorldManager(): WorldManager {\n        return this.worldManager;\n    }\n\n    /**\n     * Returns the item manager.\n     * @returns {ItemManager} The item manager.\n     */\n    public getItemManager(): ItemManager {\n        return this.itemManager;\n    }\n\n    /**\n     * Returns the block manager.\n     * @returns {BlockManager} The block manager.\n     */\n    public getBlockManager(): BlockManager {\n        return this.blockManager;\n    }\n\n    /**\n     * Returns the logger.\n     * @returns {LoggerBuilder} The logger.\n     * @example\n     * ```typescript\n     * // Normal log:\n     * server.getLogger().info('Hello, world!');\n     * // Debug log:\n     * server.getLogger().debug('Hello, world!');\n     * // Error log:\n     * server.getLogger().error(new Error('Hello World'));\n     * ```\n     */\n    public getLogger(): Logger {\n        return this.logger;\n    }\n\n    /**\n     * Returns the packet registry.\n     * @returns {PacketRegistry} The packet registry.\n     */\n    public getPacketRegistry(): PacketRegistry {\n        return this.packetRegistry;\n    }\n\n    /**\n     * Returns the raknet instance.\n     * @returns {RakNetListener | undefined} The raknet instance.\n     */\n    public getRaknet(): RakNetListener | undefined {\n        return this.raknet;\n    }\n\n    /**\n     * Returns the chat manager.\n     * @returns {ChatManager} The chat manager.\n     */\n    public getChatManager(): ChatManager {\n        return this.chatManager;\n    }\n\n    /**\n     * Returns the config.\n     * @returns {Config} The config.\n     * @example\n     * ```typescript\n     * console.log(server.getConfig().getMaxPlayers()); // 20\n     * ```\n     */\n    public getConfig(): Config {\n        return this.config;\n    }\n\n    /**\n     * Returns the console instance.\n     * @returns {Console | undefined} The console instance.\n     */\n    public getConsole() {\n        return this.console;\n    }\n\n    /**\n     * Returns the permission manager.\n     * @returns {PermissionManager} The permission manager.\n     */\n    public getPermissionManager(): PermissionManager {\n        return this.permissionManager;\n    }\n\n    /**\n     * Returns the ban manager.\n     * @returns {BanManager} The ban manager.\n     */\n    public getBanManager(): BanManager {\n        return this.banManager;\n    }\n\n    /**\n     * Returns this Prismarine instance.\n     * @returns {Server} The Prismarine instance.\n     */\n    public getServer(): Server {\n        return this;\n    }\n\n    /**\n     * Returns the current Tick.\n     * @returns {number} The current Tick.\n     */\n    public getTick(): number {\n        return Number(this.currentTick);\n    }\n\n    /**\n     * Returns the current TPS.\n     * @returns {number} The current TPS.\n     */\n    public getTPS(): number {\n        return Number.parseFloat(this.tps.toFixed(2));\n    }\n}\n"],"names":["EventEmitter","SessionManager","version","Identifiers","PacketRegistry","ItemManager","BlockManager","WorldManager","Console","CommandManager","QueryManager","ChatManager","PermissionManager","BanManager","BlockMappings","RakNetListener","ServerName","RaknetConnectEvent","Timer","ClientConnection","RaknetDisconnectEvent","RaknetEncapsulatedPacketEvent","BatchPacket","packet","TickEvent"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAqB,eAAeA,gCAAa,CAAA;AAAA,EACrC,MAAA;AAAA,EACS,MAAA;AAAA,EACA,MAAA;AAAA,EACA,OAAA;AAAA,EACA,cAAA;AAAA,EACA,cAAA,GAAiB,IAAIC,sBAAe,EAAA;AAAA,EACpC,cAAA;AAAA,EACA,YAAA;AAAA,EACA,WAAA;AAAA,EACA,YAAA;AAAA,EACA,YAAA;AAAA,EACA,WAAA;AAAA,EACA,iBAAA;AAAA,EACA,UAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMT,QAAW,GAAA,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMX,WAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,GAAM,GAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMN,WAAc,GAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAML,QAAA;AAAA;AAAA,EAGjB,OAAwB,yBAAyB,GAAO,GAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASjD,YAAY,EAAE,MAAA,EAAQ,MAAQ,EAAA,QAAA,GAAW,OAAiE,EAAA;AAC7G,IAAM,KAAA,EAAA;AAEN,IAAA,IAAA,CAAK,QAAW,GAAA,QAAA;AAEhB,IAAO,MAAA,CAAA,IAAA;AAAA,MACH,CAAA,wCAAA,EAA2CC,gBAAO,CAAA,kCAAA,EAAqCC,2BAAY,CAAA,iBAAA,CAAkB,GAAG,CAAE,CAAA,CAAC,CAAwB,qBAAA,EAAAA,2BAAA,CAAY,QAAQ,CAAA,GAAA;AAAA,KAC3K;AAEA,IAAA,IAAA,CAAK,MAAS,GAAA,MAAA;AACd,IAAA,IAAA,CAAK,MAAS,GAAA,MAAA;AACd,IAAK,IAAA,CAAA,cAAA,GAAiB,IAAIC,8BAAA,CAAe,IAAI,CAAA;AAC7C,IAAK,IAAA,CAAA,WAAA,GAAc,IAAIC,wBAAA,CAAY,IAAI,CAAA;AACvC,IAAK,IAAA,CAAA,YAAA,GAAe,IAAIC,0BAAA,CAAa,IAAI,CAAA;AACzC,IAAK,IAAA,CAAA,YAAA,GAAe,IAAIC,0BAAA,CAAa,IAAI,CAAA;AACzC,IAAA,IAAI,CAAC,IAAK,CAAA,QAAA,OAAe,OAAU,GAAA,IAAIC,gBAAQ,IAAI,CAAA;AACnD,IAAK,IAAA,CAAA,cAAA,GAAiB,IAAIC,qCAAA,CAAe,IAAI,CAAA;AAC7C,IAAK,IAAA,CAAA,YAAA,GAAe,IAAIC,+BAAA,CAAa,IAAI,CAAA;AACzC,IAAK,IAAA,CAAA,WAAA,GAAc,IAAIC,4BAAA,CAAY,IAAI,CAAA;AACvC,IAAK,IAAA,CAAA,iBAAA,GAAoB,IAAIC,8CAAA,CAAkB,IAAI,CAAA;AACnD,IAAK,IAAA,CAAA,UAAA,GAAa,IAAIC,sBAAA,CAAW,IAAI,CAAA;AAAA;AACzC;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAc,MAAwB,GAAA;AAClC,IAAM,MAAAC,iCAAA,CAAc,aAAa,IAAI,CAAA;AAErC,IAAM,MAAA,IAAA,CAAK,OAAO,MAAO,EAAA;AACzB,IAAM,MAAA,IAAA,CAAK,SAAS,MAAO,EAAA;AAC3B,IAAM,MAAA,IAAA,CAAK,OAAO,MAAO,EAAA;AACzB,IAAM,MAAA,IAAA,CAAK,kBAAkB,MAAO,EAAA;AACpC,IAAM,MAAA,IAAA,CAAK,eAAe,MAAO,EAAA;AACjC,IAAM,MAAA,IAAA,CAAK,YAAY,MAAO,EAAA;AAC9B,IAAM,MAAA,IAAA,CAAK,aAAa,MAAO,EAAA;AAC/B,IAAM,MAAA,IAAA,CAAK,WAAW,MAAO,EAAA;AAC7B,IAAM,MAAA,IAAA,CAAK,eAAe,MAAO,EAAA;AACjC,IAAM,MAAA,IAAA,CAAK,aAAa,MAAO,EAAA;AAE/B,IAAK,IAAA,CAAA,MAAA,CAAO,UAAW,CAAA,IAAA,CAAK,OAAO,CAAA;AAAA;AACvC;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAc,OAAyB,GAAA;AACnC,IAAM,MAAA,IAAA,CAAK,aAAa,OAAQ,EAAA;AAChC,IAAM,MAAA,IAAA,CAAK,eAAe,OAAQ,EAAA;AAClC,IAAM,MAAA,IAAA,CAAK,WAAW,OAAQ,EAAA;AAC9B,IAAM,MAAA,IAAA,CAAK,aAAa,OAAQ,EAAA;AAChC,IAAM,MAAA,IAAA,CAAK,YAAY,OAAQ,EAAA;AAC/B,IAAM,MAAA,IAAA,CAAK,kBAAkB,OAAQ,EAAA;AACrC,IAAM,MAAA,IAAA,CAAK,eAAe,OAAQ,EAAA;AAClC,IAAM,MAAA,IAAA,CAAK,OAAO,OAAQ,EAAA;AAC1B,IAAM,MAAA,IAAA,CAAK,OAAO,OAAQ,EAAA;AAE1B,IAAAA,iCAAA,CAAc,KAAM,EAAA;AAAA;AACxB,EAEO,WAAc,GAAA;AACjB,IAAA,IAAI,CAAC,IAAK,CAAA,MAAA,EAAc,MAAA,IAAI,MAAM,uBAAuB,CAAA;AACzD,IAAA,OAAO,KAAK,MAAO,CAAA,UAAA;AAAA;AACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,MAAwB,GAAA;AACjC,IAAA,MAAM,KAAK,OAAQ,EAAA;AACnB,IAAA,MAAM,KAAK,MAAO,EAAA;AAAA;AACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,SAAA,CAAU,QAAW,GAAA,SAAA,EAAW,OAAO,KAAsB,EAAA;AACtE,IAAA,MAAM,KAAK,MAAO,EAAA;AAElB,IAAA,IAAA,CAAK,SAAS,IAAIC,qBAAA;AAAA,MACd,IAAA,CAAK,SAAU,EAAA,CAAE,aAAc,EAAA;AAAA,MAC/B,IAAA,CAAK,SAAU,EAAA,CAAE,aAAc,EAAA;AAAA,MAC/B,IAAIC,kBAAW,IAAI,CAAA;AAAA,MACnB,KAAK,SAAU;AAAA,KACnB;AACA,IAAK,IAAA,CAAA,MAAA,CAAO,KAAM,CAAA,QAAA,EAAU,IAAI,CAAA;AAEhC,IAAA,IAAA,CAAK,MAAO,CAAA,EAAA,CAAG,gBAAkB,EAAA,OAAO,OAA2B,KAAA;AAC/D,MAAM,MAAA,KAAA,GAAQ,IAAIC,wCAAA,CAAmB,OAAO,CAAA;AAC5C,MAAM,MAAA,IAAA,CAAK,IAAK,CAAA,eAAA,EAAiB,KAAK,CAAA;AAEtC,MAAI,IAAA,KAAA,CAAM,aAAe,EAAA;AACrB,QAAA,OAAA,CAAQ,UAAW,EAAA;AACnB,QAAA;AAAA;AAGJ,MAAA,MAAM,KAAQ,GAAA,OAAA,CAAQ,UAAW,EAAA,CAAE,OAAQ,EAAA;AAC3C,MAAA,IAAI,IAAK,CAAA,cAAA,CAAe,GAAI,CAAA,KAAK,CAAG,EAAA;AAChC,QAAA,IAAA,CAAK,MAAO,CAAA,KAAA,CAAM,CAA8B,2BAAA,EAAA,KAAK,CAAyB,uBAAA,CAAA,CAAA;AAC9E,QAAA,OAAA,CAAQ,WAAW,yCAAyC,CAAA;AAC5D,QAAA;AAAA;AAGJ,MAAM,MAAA,KAAA,GAAQ,IAAIC,mBAAM,EAAA;AACxB,MAAA,IAAA,CAAK,MAAO,CAAA,KAAA,CAAM,CAAG,EAAA,KAAK,CAA2B,yBAAA,CAAA,CAAA;AACrD,MAAK,IAAA,CAAA,cAAA,CAAe,IAAI,KAAO,EAAA,IAAIC,iCAAiB,OAAS,EAAA,IAAA,CAAK,MAAM,CAAC,CAAA;AACzE,MAAA,IAAA,CAAK,OAAO,OAAQ,CAAA,CAAA,+BAAA,EAAkC,KAAM,CAAA,IAAA,EAAM,CAAO,KAAA,CAAA,CAAA;AAAA,KAC5E,CAAA;AAED,IAAA,IAAA,CAAK,MAAO,CAAA,EAAA,CAAG,iBAAmB,EAAA,OAAO,UAAuB,MAAmB,KAAA;AAC/E,MAAA,MAAM,KAAQ,GAAA,IAAIC,2CAAsB,CAAA,QAAA,EAAU,MAAM,CAAA;AACxD,MAAM,MAAA,IAAA,CAAK,IAAK,CAAA,kBAAA,EAAoB,KAAK,CAAA;AAEzC,MAAM,MAAA,IAAA,GAAO,KAAK,GAAI,EAAA;AACtB,MAAM,MAAA,KAAA,GAAQ,SAAS,OAAQ,EAAA;AAE/B,MAAA,MAAM,OAAU,GAAA,IAAA,CAAK,cAAe,CAAA,GAAA,CAAI,KAAK,CAAA;AAC7C,MAAA,IAAI,CAAC,OAAS,EAAA;AACV,QAAA,IAAA,CAAK,MAAO,CAAA,KAAA,CAAM,CAAsD,mDAAA,EAAA,KAAK,CAAG,CAAA,CAAA,CAAA;AAChF,QAAA;AAAA;AAGJ,MAAA,MAAM,QAAQ,kBAAmB,EAAA;AAEjC,MAAK,IAAA,CAAA,cAAA,CAAe,OAAO,KAAK,CAAA;AAChC,MAAA,IAAA,CAAK,OAAO,KAAM,CAAA,CAAA,EAAG,KAAK,CAAA,qBAAA,EAAwB,MAAM,CAAE,CAAA,CAAA;AAC1D,MAAA,IAAA,CAAK,OAAO,KAAM,CAAA,CAAA,8BAAA,EAAiC,KAAK,GAAI,EAAA,GAAI,IAAI,CAAK,GAAA,CAAA,CAAA;AAAA,KAC5E,CAAA;AAED,IAAA,IAAA,CAAK,MAAO,CAAA,EAAA,CAAG,cAAgB,EAAA,OAAO,QAAa,QAA0B,KAAA;AACzE,MAAA,MAAM,KAAQ,GAAA,IAAIC,mDAA8B,CAAA,QAAA,EAAU,MAAM,C