node-metaverse/lib/Bot.ts

import { LoginHandler } from './LoginHandler';
import type { LoginResponse } from './classes/LoginResponse';
import type { LoginParameters } from './classes/LoginParameters';
import type { Agent } from './classes/Agent';
import { PacketFlags } from './enums/PacketFlags';
import { UseCircuitCodeMessage } from './classes/messages/UseCircuitCode';
import { CompleteAgentMovementMessage } from './classes/messages/CompleteAgentMovement';
import { Message } from './enums/Message';
import type { Packet } from './classes/Packet';
import type { Region } from './classes/Region';
import { LogoutRequestMessage } from './classes/messages/LogoutRequest';
import { Utils } from './classes/Utils';
import { RegionHandshakeReplyMessage } from './classes/messages/RegionHandshakeReply';
import { RegionProtocolFlags } from './enums/RegionProtocolFlags';
import { AgentDataUpdateRequestMessage } from './classes/messages/AgentDataUpdateRequest';
import type { TeleportProgressMessage } from './classes/messages/TeleportProgress';
import { TeleportEvent } from './events/TeleportEvent';
import { ClientEvents } from './classes/ClientEvents';
import { TeleportEventType } from './enums/TeleportEventType';
import { ClientCommands } from './classes/ClientCommands';
import { DisconnectEvent } from './events/DisconnectEvent';
import type { KickUserMessage } from './classes/messages/KickUser';
import { StartPingCheckMessage } from './classes/messages/StartPingCheck';
import type { CompletePingCheckMessage } from './classes/messages/CompletePingCheck';
import type { BotOptionFlags } from './enums/BotOptionFlags';
import { FilterResponse } from './enums/FilterResponse';
import type { LogoutReplyMessage } from './classes/messages/LogoutReply';
import type { EventQueueStateChangeEvent } from './events/EventQueueStateChangeEvent';
import { UUID } from './classes/UUID';
import { Vector3 } from './classes/Vector3';
import type { RegionHandshakeMessage } from './classes/messages/RegionHandshake';
import type { AgentMovementCompleteMessage } from './classes/messages/AgentMovementComplete';
import type { Subscription } from 'rxjs';

export class Bot
{
    public clientEvents: ClientEvents;
    private stayRegion = '';
    private stayPosition = new Vector3();

    private readonly loginParams: LoginParameters;
    private ping: NodeJS.Timeout | null = null;
    private pingNumber = 0;
    private lastSuccessfulPing = 0;
    private circuitSubscription: Subscription | null = null;
    private readonly options: BotOptionFlags;
    private eventQueueRunning = false;
    private readonly eventQueueWaits = new Map<string,  {
        timer?: NodeJS.Timeout,
        resolve:  (value: (void | PromiseLike<void>)) => void
    }>();
    private stay = false;

    private _agent?: Agent;
    private _currentRegion?: Region;
    private _clientCommands?: ClientCommands;

    public get currentRegion(): Region
    {
        if (this._currentRegion === undefined)
        {
            throw new Error('Internal error - currentRegion is undefined');
        }
        return this._currentRegion;
    }

    public get agent(): Agent
    {
        if (this._agent === undefined)
        {
            throw new Error('Internal error - agent is undefined');
        }
        return this._agent;
    }

    public get clientCommands(): ClientCommands
    {
        if (this._clientCommands === undefined)
        {
            throw new Error('Internal error - clientCommands is undefined');
        }
        return this._clientCommands;
    }

    public get loginParameters(): LoginParameters
    {
        return this.loginParams;
    }

    public constructor(login: LoginParameters, options: BotOptionFlags)
    {
        this.clientEvents = new ClientEvents();
        this.loginParams = login;
        this.options = options;

        this.clientEvents.onEventQueueStateChange.subscribe((evt: EventQueueStateChangeEvent) =>
        {
            this.eventQueueRunning = evt.active;
            for (const waitID of this.eventQueueWaits.keys())
            {
                try
                {
                    const wait = this.eventQueueWaits.get(waitID);
                    if (wait !== undefined)
                    {
                        clearTimeout(wait.timer);
                        wait.resolve();
                        this.eventQueueWaits.delete(waitID);
                    }
                }
                catch (_ignore: unknown)
                {
                    //Nothing
                }
            }
        });
    }

    public stayPut(stay: boolean, regionName?: string, position?: Vector3): void
    {
        this.stay = stay;
        if (regionName !== undefined)
        {
            this.stayRegion = regionName;
            if (position !== undefined)
            {
                this.stayPosition = position;
            }
        }
    }

    public getCurrentRegion(): Region
    {
        return this.currentRegion;
    }

    public async login(): Promise<LoginResponse>
    {
        const loginHandler = new LoginHandler(this.clientEvents, this.options);
        const response: LoginResponse = await loginHandler.Login(this.loginParams);
        this._currentRegion = response.region;
        this._agent = response.agent;
        this._clientCommands = new ClientCommands(response.region, response.agent, this);
        this.currentRegion.clientCommands = this._clientCommands;
        return response;
    }

    public async changeRegion(region: Region, requested: boolean): Promise<void>
    {
        this.closeCircuit();
        this._currentRegion = region;
        this._clientCommands = new ClientCommands(this.currentRegion, this.agent, this);
        this._currentRegion.clientCommands = this._clientCommands;
        if (this.ping !== null)
        {
            clearInterval(this.ping);
            this.ping = null;
        }

        await this.connectToSim(requested);
    }

    public async waitForEventQueue(timeout = 1000): Promise<void>
    {
        return new Promise((resolve, reject) =>
        {
            if (this.eventQueueRunning)
            {
                resolve();
            }
            else
            {
                const waitID = UUID.random().toString();
                const newWait: {
                    resolve: (value: (void | PromiseLike<void>)) => void,
                    timer?: NodeJS.Timeout
                } = {
                    'resolve': resolve
                };

                newWait.timer = setTimeout(() =>
                {
                    this.eventQueueWaits.delete(waitID);
                    reject(new Error('Timeout'));
                }, timeout);

                this.eventQueueWaits.set(waitID, newWait);
            }
        });
    }

    public async setInterestList(mode: '360' | 'default'): Promise<boolean>
    {
        const interestList = {
            mode
        };

        try
        {
            const result = await this.currentRegion.caps.capsPostXML('InterestList', interestList);
            if (typeof result !== 'object' || result === null)
            {
                throw new Error('Invalid response received');
            }
            const res = result as Record<string, unknown>;
            return res.mode === mode;
        }
        catch (e)
        {
            console.error('Error when setting interest list:');
            console.error(e);
            return false;
        }
    }

    public async close(): Promise<void>
    {
        const circuit = this.currentRegion.circuit;
        const msg: LogoutRequestMessage = new LogoutRequestMessage();
        msg.AgentData = {
            AgentID: this.agent.agentID,
            SessionID: circuit.sessionID
        };
        circuit.sendMessage(msg, PacketFlags.Reliable);
        await circuit.waitForMessage<LogoutReplyMessage>(Message.LogoutReply, 5000);
        this.stayRegion = '';
        this.stayPosition = new Vector3();
        this.closeCircuit();
        this.agent.shutdown();
        delete this._agent;
        this.disconnected(true, 'Logout completed');
    }

    public agentID(): UUID
    {
        return this.agent.agentID;
    }

    public async connectToSim(requested = false): Promise<void>
    {
        if (!requested)
        {
            if (this.stay && this.stayRegion === '')
            {
                requested = true;
            }
        }

        this.agent.setCurrentRegion(this.currentRegion);
        const circuit = this.currentRegion.circuit;
        circuit.init();
        const msg: UseCircuitCodeMessage = new UseCircuitCodeMessage();
        msg.CircuitCode = {
            SessionID: circuit.sessionID,
            ID: this.agent.agentID,
            Code: circuit.circuitCode
        };

        await circuit.waitForAck(circuit.sendMessage(msg, PacketFlags.Reliable), 60000);


        const agentMovement: CompleteAgentMovementMessage = new CompleteAgentMovementMessage();
        agentMovement.AgentData = {
            AgentID: this.agent.agentID,
            SessionID: circuit.sessionID,
            CircuitCode: circuit.circuitCode
        };
        circuit.sendMessage(agentMovement, PacketFlags.Reliable);

        let agentPosition: Vector3 | null = null;
        let regionName: string | null = null;

        circuit.waitForMessage<AgentMovementCompleteMessage>(Message.AgentMovementComplete, 60000).then((agentMovementMsg: AgentMovementCompleteMessage) =>
        {
            agentPosition = agentMovementMsg.Data.Position;
            if (regionName !== null)
            {
                if (this.stayRegion === '' || requested)
                {
                    this.stayPut(this.stay, regionName, agentPosition);
                }
            }
        }).catch(() =>
        {
            console.error('Timed out waiting for AgentMovementComplete')
        });

        const handshakeMessage = await circuit.waitForMessage<RegionHandshakeMessage>(Message.RegionHandshake, 10000);

        const handshakeReply: RegionHandshakeReplyMessage = new RegionHandshakeReplyMessage();
        handshakeReply.AgentData = {
            AgentID: this.agent.agentID,
            SessionID: circuit.sessionID
        };
        handshakeReply.RegionInfo = {
            Flags: RegionProtocolFlags.SelfAppearanceSupport | RegionProtocolFlags.AgentAppearanceService
        };
        await circuit.waitForAck(circuit.sendMessage(handshakeReply, PacketFlags.Reliable), 10000);

        this.currentRegion.handshake(handshakeMessage).then(() =>
        {
            regionName = this.currentRegion.regionName;
            console.log('Arrived in region: ' + regionName);
            if (agentPosition !== null)
            {
                if (this.stayRegion === '' || requested)
                {
                    this.stayPut(this.stay, regionName, agentPosition);
                }
            }
        }).catch((error: unknown) =>
        {
            console.error('Timed out getting handshake');
            console.error(error);
        });

        if (this._clientCommands)
        {
            await this._clientCommands.network.setBandwidth(1536000);
        }

        const agentRequest = new AgentDataUpdateRequestMessage();
        agentRequest.AgentData = {
            AgentID: this.agent.agentID,
            SessionID: circuit.sessionID
        };
        circuit.sendMessage(agentRequest, PacketFlags.Reliable);
        await this.agent.setInitialAppearance();
        this.agent.circuitActive();

        this.lastSuccessfulPing = new Date().getTime();

        this.ping = setInterval(() => {
            (async(): Promise<void> =>
            {
                const now = new Date().getTime();
                if (now - this.lastSuccessfulPing > 120 * 1000)
                {
                    if (this.ping !== null)
                    {
                        clearInterval(this.ping);
                        this.ping = null;
                        this.disconnected(false, 'Disconnected from the simulator');
                    }
                    return;
                }

                this.pingNumber++;
                if (this.pingNumber % 12 === 0 && this.stay)
                {
                    if (this.currentRegion.regionName.toLowerCase() !== this.stayRegion.toLowerCase())
                    {
                        console.log('Stay Put: Attempting to teleport to ' + this.stayRegion);
                        if (this.stayPosition === undefined)
                        {
                            this.stayPosition = new Vector3([128, 128, 20]);
                        }
                        this.clientCommands.teleport.teleportTo(this.stayRegion, this.stayPosition, this.stayPosition).then(() =>
                        {
                            console.log('I found my way home.');
                        }).catch(() =>
                        {
                            console.log('Cannot teleport home right now.');
                        });
                    }
                }
                if (this.pingNumber > 255)
                {
                    this.pingNumber = 0;
                }
                const ping = new StartPingCheckMessage();
                ping.PingID = {
                    PingID: this.pingNumber,
                    OldestUnacked: this.currentRegion.circuit.getOldestUnacked()
                };
                circuit.sendMessage(ping, PacketFlags.Reliable);

                await circuit.waitForMessage<CompletePingCheckMessage>(Message.CompletePingCheck, 10000, ((pingData: {
                    pingID: number,
                    timeSent: number
                }, cpc: CompletePingCheckMessage): FilterResponse =>
                {
                    if (cpc.PingID.PingID === pingData.pingID)
                    {
                        this.lastSuccessfulPing = new Date().getTime();
                        const pingTime = this.lastSuccessfulPing - pingData.timeSent;
                        if (this.clientEvents !== null)
                        {
                            this.clientEvents.onCircuitLatency.next(pingTime);
                        }
                        return FilterResponse.Finish;
                    }
                    return FilterResponse.NoMatch;
                }).bind(this, {
                    pingID: this.pingNumber,
                    timeSent: new Date().getTime()
                }));

                if ((new Date().getTime() - this.lastSuccessfulPing) > 60000)
                {
                    // We're dead, jim
                    this.kicked('Circuit Timeout');
                }

            })().catch((_e: unknown) => { /*ignore*/ })
        }, 5000);

        this.circuitSubscription = circuit.subscribeToMessages(
            [
                Message.TeleportFailed,
                Message.TeleportFinish,
                Message.TeleportLocal,
                Message.TeleportStart,
                Message.TeleportProgress,
                Message.TeleportCancel,
                Message.KickUser
            ], (packet: Packet) =>
            {
                switch (packet.message.id)
                {
                    case Message.TeleportLocal:
                    {
                        const tpEvent = new TeleportEvent();
                        tpEvent.message = '';
                        tpEvent.eventType = TeleportEventType.TeleportCompleted;
                        tpEvent.simIP = 'local';
                        tpEvent.simPort = 0;
                        tpEvent.seedCapability = '';

                        if (this.clientEvents === null)
                        {
                            this.kicked('ClientEvents is null');
                        }

                        this.clientEvents.onTeleportEvent.next(tpEvent);
                        break;
                    }
                    case Message.TeleportStart:
                    {
                        const tpEvent = new TeleportEvent();
                        tpEvent.message = '';
                        tpEvent.eventType = TeleportEventType.TeleportStarted;
                        tpEvent.simIP = '';
                        tpEvent.simPort = 0;
                        tpEvent.seedCapability = '';

                        if (this.clientEvents === null)
                        {
                            this.kicked('ClientEvents is null');
                        }

                        this.clientEvents.onTeleportEvent.next(tpEvent);
                        break;
                    }
                    case Message.TeleportProgress:
                    {
                        const teleportProgress = packet.message as TeleportProgressMessage;
                        const message = Utils.BufferToStringSimple(teleportProgress.Info.Message);

                        const tpEvent = new TeleportEvent();
                        tpEvent.message = message;
                        tpEvent.eventType = TeleportEventType.TeleportProgress;
                        tpEvent.simIP = '';
                        tpEvent.simPort = 0;
                        tpEvent.seedCapability = '';

                        if (this.clientEvents === null)
                        {
                            this.kicked('ClientEvents is null');
                        }

                        this.clientEvents.onTeleportEvent.next(tpEvent);
                        break;
                    }
                    case Message.KickUser:
                    {
                        const kickUser = packet.message as KickUserMessage;
                        this.kicked(Utils.BufferToStringSimple(kickUser.UserInfo.Reason));

                        break;
                    }
                    default:
                        break;
                }
            });
    }

    private closeCircuit(): void
    {
        this.currentRegion.shutdown();
        if (this.circuitSubscription !== null)
        {
            this.circuitSubscription.unsubscribe();
            this.circuitSubscription = null;
        }
        delete this._currentRegion;

        this.clientCommands.shutdown();
        delete this._clientCommands;
        if (this.ping !== null)
        {
            clearInterval(this.ping);
            this.ping = null;
        }

    }

    private kicked(message: string): void
    {
        this.closeCircuit();
        this.agent.shutdown();
        delete this._agent;
        this.disconnected(false, message);
    }

    private disconnected(requested: boolean, message: string): void
    {
        const disconnectEvent = new DisconnectEvent();
        disconnectEvent.requested = requested;
        disconnectEvent.message = message;
        if (this.clientEvents)
        {
            this.clientEvents.onDisconnected.next(disconnectEvent);
        }
    }
}