@jsprismarine/prismarine
Version:
Dedicated Minecraft Bedrock Edition server written in TypeScript
450 lines (449 loc) • 49.4 kB
JavaScript
import { ChatManager } from "./chat/ChatManager.es.js";
import { PermissionManager } from "./permission/PermissionManager.es.js";
import { QueryManager } from "./query/QueryManager.es.js";
import SessionManager from "./SessionManager.es.js";
import BanManager from "./ban/BanManager.es.js";
import Timer from "./utils/Timer.es.js";
import BlockManager from "./block/BlockManager.es.js";
import { BlockMappings } from "./block/BlockMappings.es.js";
import ItemManager from "./item/ItemManager.es.js";
import Identifiers from "./network/Identifiers.es.js";
import BatchPacket from "./network/packet/BatchPacket.es.js";
import WorldManager from "./world/WorldManager.es.js";
import { CommandManager } from "./command/CommandManager.es.js";
import RaknetConnectEvent from "./events/raknet/RaknetConnectEvent.es.js";
import RaknetDisconnectEvent from "./events/raknet/RaknetDisconnectEvent.es.js";
import RaknetEncapsulatedPacketEvent from "./events/raknet/RaknetEncapsulatedPacketEvent.es.js";
import TickEvent from "./events/other/TickEvent.es.js";
import Console from "./Console.es.js";
import { EventEmitter } from "./events/EventEmitter.es.js";
import ClientConnection from "./network/ClientConnection.es.js";
import PacketRegistry from "./network/PacketRegistry.es.js";
import { version } from "./package.json.es.js";
import { RakNetListener, ServerName } from "@jsprismarine/raknet";
//#region src/Server.ts
/**
* JSPrismarine's main server class.
* @public
*/
var Server = class Server extends EventEmitter {
raknet;
logger;
config;
console;
packetRegistry;
sessionManager = new SessionManager();
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;
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${version}§r for Minecraft: Bedrock Edition ${Identifiers.MinecraftVersions.at(-1)} (protocol version §e${Identifiers.Protocol}§r)`);
this.logger = logger;
this.config = config;
this.packetRegistry = new PacketRegistry(this);
this.itemManager = new ItemManager(this);
this.blockManager = new BlockManager(this);
this.worldManager = new WorldManager(this);
if (!this.headless) this.console = new Console(this);
this.commandManager = new CommandManager(this);
this.queryManager = new QueryManager(this);
this.chatManager = new ChatManager(this);
this.permissionManager = new PermissionManager(this);
this.banManager = new BanManager(this);
}
/**
* Enables the server.
* @returns {Promise<void>} A promise that resolves when the server is enabled.
* @internal
*/
async enable() {
await 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();
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 RakNetListener(this.getConfig().getMaxPlayers(), this.getConfig().getOnlineMode(), new ServerName(this), this.getLogger());
this.raknet.start(serverIp, port);
this.raknet.on("openConnection", async (session) => {
const event = new RaknetConnectEvent(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 Timer();
this.logger.debug(`${token} is attempting to connect`);
this.sessionManager.add(token, new ClientConnection(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 RaknetDisconnectEvent(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 RaknetEncapsulatedPacketEvent(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 BatchPacket(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 packet = new (this.packetRegistry.getPackets().get(pid))(buf);
try {
packet.decode();
} catch (error) {
this.logger.error(error);
this.logger.error(`Error while decoding packet: ${packet.constructor.name}: ${error}`);
continue;
}
try {
const handler = this.packetRegistry.getHandler(pid);
this.logger.silly(`Received §b${packet.constructor.name}§r packet`);
await handler.handle(packet, this, connection.getPlayerSession() ?? connection);
} catch (error) {
this.logger.error(`Handler error ${packet.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 TickEvent(this.getTick());
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, Math.max(0, sleepTime));
this.tickerTimer.unref();
};
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 version;
}
/**
* Returns the identifiers.
* @returns {Identifiers} The identifiers.
*/
getIdentifiers() {
return Identifiers;
}
/**
* 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));
}
};
//#endregion
export { Server as default };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"Server.es.js","names":[],"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, Math.max(0, 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"],"mappings":"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"}