415 lines
20 KiB
JavaScript
415 lines
20 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const LoginHandler_1 = require("./LoginHandler");
|
|
const UUID_1 = require("./classes/UUID");
|
|
const PacketFlags_1 = require("./enums/PacketFlags");
|
|
const UseCircuitCode_1 = require("./classes/messages/UseCircuitCode");
|
|
const CompleteAgentMovement_1 = require("./classes/messages/CompleteAgentMovement");
|
|
const Message_1 = require("./enums/Message");
|
|
const Region_1 = require("./classes/Region");
|
|
const LogoutRequest_1 = require("./classes/messages/LogoutRequest");
|
|
const Utils_1 = require("./classes/Utils");
|
|
const RegionHandshakeReply_1 = require("./classes/messages/RegionHandshakeReply");
|
|
const RegionProtocolFlags_1 = require("./enums/RegionProtocolFlags");
|
|
const AgentThrottle_1 = require("./classes/messages/AgentThrottle");
|
|
const AgentDataUpdateRequest_1 = require("./classes/messages/AgentDataUpdateRequest");
|
|
const RegionHandleRequest_1 = require("./classes/messages/RegionHandleRequest");
|
|
const MapItemRequest_1 = require("./classes/messages/MapItemRequest");
|
|
const GridItemType_1 = require("./enums/GridItemType");
|
|
const MapBlockRequest_1 = require("./classes/messages/MapBlockRequest");
|
|
const MapInfoReply_1 = require("./events/MapInfoReply");
|
|
const TeleportLureRequest_1 = require("./classes/messages/TeleportLureRequest");
|
|
const TeleportFlags_1 = require("./enums/TeleportFlags");
|
|
const LLSD = require("llsd");
|
|
const TeleportEvent_1 = require("./events/TeleportEvent");
|
|
const TeleportEventType_1 = require("./enums/TeleportEventType");
|
|
class Bot {
|
|
constructor(login) {
|
|
this.throttleGenCounter = 0;
|
|
this.clientEvents = null;
|
|
this.loginParams = login;
|
|
}
|
|
login() {
|
|
return new Promise((resolve, reject) => {
|
|
const loginHandler = new LoginHandler_1.LoginHandler();
|
|
loginHandler.Login(this.loginParams).then((response) => {
|
|
this.clientEvents = response.clientEvents;
|
|
this.currentRegion = response.region;
|
|
this.agent = response.agent;
|
|
resolve(response);
|
|
}).catch((error) => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
close() {
|
|
return new Promise((resolve, reject) => {
|
|
const circuit = this.currentRegion.circuit;
|
|
const msg = new LogoutRequest_1.LogoutRequestMessage();
|
|
msg.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: circuit.sessionID
|
|
};
|
|
circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
|
|
circuit.waitForMessage(Message_1.Message.LogoutReply, 5000).then((packet) => {
|
|
}).catch((error) => {
|
|
console.error('Timeout waiting for logout reply');
|
|
}).then(() => {
|
|
this.agent.shutdown();
|
|
this.currentRegion.shutdown();
|
|
delete this.currentRegion;
|
|
delete this.agent;
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
setBandwidth(total) {
|
|
const circuit = this.currentRegion.circuit;
|
|
const agentThrottle = new AgentThrottle_1.AgentThrottleMessage();
|
|
agentThrottle.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: circuit.sessionID,
|
|
CircuitCode: circuit.circuitCode
|
|
};
|
|
const throttleData = Buffer.allocUnsafe(28);
|
|
let pos = 0;
|
|
const resendThrottle = total * 0.1;
|
|
const landThrottle = total * 0.172;
|
|
const windThrottle = total * 0.05;
|
|
const cloudThrottle = total * 0.05;
|
|
const taskThrottle = total * 0.234;
|
|
const textureThrottle = total * 0.234;
|
|
const assetThrottle = total * 0.160;
|
|
throttleData.writeFloatLE(resendThrottle, pos);
|
|
pos += 4;
|
|
throttleData.writeFloatLE(landThrottle, pos);
|
|
pos += 4;
|
|
throttleData.writeFloatLE(windThrottle, pos);
|
|
pos += 4;
|
|
throttleData.writeFloatLE(cloudThrottle, pos);
|
|
pos += 4;
|
|
throttleData.writeFloatLE(taskThrottle, pos);
|
|
pos += 4;
|
|
throttleData.writeFloatLE(textureThrottle, pos);
|
|
pos += 4;
|
|
throttleData.writeFloatLE(assetThrottle, pos);
|
|
agentThrottle.Throttle = {
|
|
GenCounter: this.throttleGenCounter++,
|
|
Throttles: throttleData
|
|
};
|
|
circuit.sendMessage(agentThrottle, PacketFlags_1.PacketFlags.Reliable);
|
|
}
|
|
acceptTeleport(lure) {
|
|
return new Promise((resolve, reject) => {
|
|
const circuit = this.currentRegion.circuit;
|
|
const tlr = new TeleportLureRequest_1.TeleportLureRequestMessage();
|
|
tlr.Info = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: circuit.sessionID,
|
|
LureID: lure.lureID,
|
|
TeleportFlags: TeleportFlags_1.TeleportFlags.ViaLure
|
|
};
|
|
circuit.sendMessage(tlr, PacketFlags_1.PacketFlags.Reliable);
|
|
if (this.currentRegion.caps.eventQueueClient) {
|
|
if (this.clientEvents === null) {
|
|
reject(new Error('ClientEvents is null'));
|
|
return;
|
|
}
|
|
const subscription = this.clientEvents.onTeleportEvent.subscribe((e) => {
|
|
if (e.eventType === TeleportEventType_1.TeleportEventType.TeleportFailed || e.eventType === TeleportEventType_1.TeleportEventType.TeleportCompleted) {
|
|
subscription.unsubscribe();
|
|
}
|
|
if (e.eventType === TeleportEventType_1.TeleportEventType.TeleportFailed) {
|
|
reject(e);
|
|
}
|
|
else if (e.eventType === TeleportEventType_1.TeleportEventType.TeleportCompleted) {
|
|
if (e.simIP === 'local') {
|
|
resolve(e);
|
|
return;
|
|
}
|
|
if (this.clientEvents === null) {
|
|
reject(new Error('ClientEvents is null'));
|
|
return;
|
|
}
|
|
this.currentRegion.shutdown();
|
|
const region = new Region_1.Region(this.agent, this.clientEvents);
|
|
region.circuit.circuitCode = this.currentRegion.circuit.circuitCode;
|
|
region.circuit.secureSessionID = this.currentRegion.circuit.secureSessionID;
|
|
region.circuit.sessionID = this.currentRegion.circuit.sessionID;
|
|
region.circuit.udpBlacklist = this.currentRegion.circuit.udpBlacklist;
|
|
region.circuit.ipAddress = e.simIP;
|
|
region.circuit.port = e.simPort;
|
|
this.agent.setCurrentRegion(region);
|
|
this.currentRegion = region;
|
|
this.currentRegion.activateCaps(e.seedCapability);
|
|
this.connectToSim().then(() => {
|
|
resolve(e);
|
|
}).catch((error) => {
|
|
reject(e);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
getRegionHandle(regionID) {
|
|
return new Promise((resolve, reject) => {
|
|
const circuit = this.currentRegion.circuit;
|
|
const msg = new RegionHandleRequest_1.RegionHandleRequestMessage();
|
|
msg.RequestBlock = {
|
|
RegionID: regionID,
|
|
};
|
|
circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
|
|
circuit.waitForMessage(Message_1.Message.RegionIDAndHandleReply, 10000, (packet) => {
|
|
const filterMsg = packet.message;
|
|
return (filterMsg.ReplyBlock.RegionID.toString() === regionID.toString());
|
|
}).then((packet) => {
|
|
const responseMsg = packet.message;
|
|
resolve(responseMsg.ReplyBlock.RegionHandle);
|
|
});
|
|
});
|
|
}
|
|
getRegionMapInfo(gridX, gridY) {
|
|
return new Promise((resolve, reject) => {
|
|
const circuit = this.currentRegion.circuit;
|
|
const response = new MapInfoReply_1.MapInfoReply();
|
|
const msg = new MapBlockRequest_1.MapBlockRequestMessage();
|
|
msg.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: circuit.sessionID,
|
|
Flags: 65536,
|
|
EstateID: 0,
|
|
Godlike: true
|
|
};
|
|
msg.PositionData = {
|
|
MinX: (gridX / 256),
|
|
MaxX: (gridX / 256),
|
|
MinY: (gridY / 256),
|
|
MaxY: (gridY / 256)
|
|
};
|
|
circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
|
|
circuit.waitForMessage(Message_1.Message.MapBlockReply, 10000, (packet) => {
|
|
const filterMsg = packet.message;
|
|
let found = false;
|
|
filterMsg.Data.forEach((data) => {
|
|
if (data.X === (gridX / 256) && data.Y === (gridY / 256)) {
|
|
found = true;
|
|
}
|
|
});
|
|
return found;
|
|
}).then((packet) => {
|
|
const responseMsg = packet.message;
|
|
responseMsg.Data.forEach((data) => {
|
|
if (data.X === (gridX / 256) && data.Y === (gridY / 256)) {
|
|
response.name = Utils_1.Utils.BufferToStringSimple(data.Name);
|
|
response.accessFlags = data.Access;
|
|
response.mapImage = data.MapImageID;
|
|
}
|
|
});
|
|
const regionHandle = Utils_1.Utils.RegionCoordinatesToHandle(gridX, gridY);
|
|
const mi = new MapItemRequest_1.MapItemRequestMessage();
|
|
mi.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: circuit.sessionID,
|
|
Flags: 2,
|
|
EstateID: 0,
|
|
Godlike: false
|
|
};
|
|
mi.RequestData = {
|
|
ItemType: GridItemType_1.GridItemType.AgentLocations,
|
|
RegionHandle: regionHandle
|
|
};
|
|
circuit.sendMessage(mi, PacketFlags_1.PacketFlags.Reliable);
|
|
const minX = Math.floor(gridX / 256) * 256;
|
|
const maxX = minX + 256;
|
|
const minY = Math.floor(gridY / 256) * 256;
|
|
const maxY = minY + 256;
|
|
response.avatars = [];
|
|
circuit.waitForMessage(Message_1.Message.MapItemReply, 10000, (packet) => {
|
|
const filterMsg = packet.message;
|
|
let found = false;
|
|
filterMsg.Data.forEach((data) => {
|
|
if (data.X >= minX && data.X <= maxX && data.Y >= minY && data.Y <= maxY) {
|
|
found = true;
|
|
}
|
|
});
|
|
return found;
|
|
}).then((packet2) => {
|
|
const responseMsg2 = packet2.message;
|
|
responseMsg2.Data.forEach((data) => {
|
|
response.avatars.push({
|
|
X: data.X,
|
|
Y: data.Y
|
|
});
|
|
});
|
|
resolve(response);
|
|
}).catch((err) => {
|
|
reject(err);
|
|
});
|
|
}).catch((err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
}
|
|
connectToSim() {
|
|
return new Promise((resolve, reject) => {
|
|
const circuit = this.currentRegion.circuit;
|
|
circuit.init();
|
|
const msg = new UseCircuitCode_1.UseCircuitCodeMessage();
|
|
msg.CircuitCode = {
|
|
SessionID: circuit.sessionID,
|
|
ID: this.agent.agentID,
|
|
Code: circuit.circuitCode
|
|
};
|
|
circuit.waitForAck(circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable), 1000).then(() => {
|
|
const agentMovement = new CompleteAgentMovement_1.CompleteAgentMovementMessage();
|
|
agentMovement.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: circuit.sessionID,
|
|
CircuitCode: circuit.circuitCode
|
|
};
|
|
circuit.sendMessage(agentMovement, PacketFlags_1.PacketFlags.Reliable);
|
|
return circuit.waitForMessage(Message_1.Message.RegionHandshake, 10000);
|
|
}).then((packet) => {
|
|
const handshakeReply = new RegionHandshakeReply_1.RegionHandshakeReplyMessage();
|
|
handshakeReply.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: circuit.sessionID
|
|
};
|
|
handshakeReply.RegionInfo = {
|
|
Flags: RegionProtocolFlags_1.RegionProtocolFlags.SelfAppearanceSupport | RegionProtocolFlags_1.RegionProtocolFlags.AgentAppearanceService
|
|
};
|
|
return circuit.waitForAck(circuit.sendMessage(handshakeReply, PacketFlags_1.PacketFlags.Reliable), 10000);
|
|
}).then(() => {
|
|
this.setBandwidth(1536000);
|
|
const agentRequest = new AgentDataUpdateRequest_1.AgentDataUpdateRequestMessage();
|
|
agentRequest.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: circuit.sessionID
|
|
};
|
|
circuit.sendMessage(agentRequest, PacketFlags_1.PacketFlags.Reliable);
|
|
this.agent.setInitialAppearance();
|
|
this.agent.circuitActive();
|
|
circuit.subscribeToMessages([
|
|
Message_1.Message.TeleportFailed,
|
|
Message_1.Message.TeleportFinish,
|
|
Message_1.Message.TeleportLocal,
|
|
Message_1.Message.TeleportStart,
|
|
Message_1.Message.TeleportProgress,
|
|
Message_1.Message.TeleportCancel,
|
|
Message_1.Message.SoundTrigger,
|
|
Message_1.Message.AttachedSound,
|
|
Message_1.Message.AvatarAnimation
|
|
], (packet) => {
|
|
switch (packet.message.id) {
|
|
case Message_1.Message.TeleportLocal:
|
|
{
|
|
const tpEvent = new TeleportEvent_1.TeleportEvent();
|
|
tpEvent.message = '';
|
|
tpEvent.eventType = TeleportEventType_1.TeleportEventType.TeleportCompleted;
|
|
tpEvent.simIP = 'local';
|
|
tpEvent.simPort = 0;
|
|
tpEvent.seedCapability = '';
|
|
if (this.clientEvents === null) {
|
|
reject(new Error('ClientEvents is null'));
|
|
return;
|
|
}
|
|
this.clientEvents.onTeleportEvent.next(tpEvent);
|
|
break;
|
|
}
|
|
case Message_1.Message.TeleportStart:
|
|
{
|
|
const teleportStart = packet.message;
|
|
const flags = teleportStart.Info.TeleportFlags;
|
|
const tpEvent = new TeleportEvent_1.TeleportEvent();
|
|
tpEvent.message = message;
|
|
tpEvent.eventType = TeleportEventType_1.TeleportEventType.TeleportProgress;
|
|
tpEvent.simIP = '';
|
|
tpEvent.simPort = 0;
|
|
tpEvent.seedCapability = '';
|
|
if (this.clientEvents === null) {
|
|
reject(new Error('ClientEvents is null'));
|
|
return;
|
|
}
|
|
this.clientEvents.onTeleportEvent.next(tpEvent);
|
|
break;
|
|
}
|
|
case Message_1.Message.TeleportProgress:
|
|
{
|
|
const teleportProgress = packet.message;
|
|
const message = Utils_1.Utils.BufferToStringSimple(teleportProgress.Info.Message);
|
|
const tpEvent = new TeleportEvent_1.TeleportEvent();
|
|
tpEvent.message = message;
|
|
tpEvent.eventType = TeleportEventType_1.TeleportEventType.TeleportProgress;
|
|
tpEvent.simIP = '';
|
|
tpEvent.simPort = 0;
|
|
tpEvent.seedCapability = '';
|
|
if (this.clientEvents === null) {
|
|
reject(new Error('ClientEvents is null'));
|
|
return;
|
|
}
|
|
this.clientEvents.onTeleportEvent.next(tpEvent);
|
|
break;
|
|
}
|
|
case Message_1.Message.SoundTrigger:
|
|
{
|
|
const soundTrigger = packet.message;
|
|
const soundID = soundTrigger.SoundData.SoundID;
|
|
break;
|
|
}
|
|
case Message_1.Message.AttachedSound:
|
|
{
|
|
const attachedSound = packet.message;
|
|
const soundID = attachedSound.DataBlock.SoundID;
|
|
break;
|
|
}
|
|
case Message_1.Message.AvatarAnimation:
|
|
{
|
|
const avatarAnimation = packet.message;
|
|
break;
|
|
}
|
|
default:
|
|
console.log('Unrecognised message');
|
|
break;
|
|
}
|
|
});
|
|
resolve();
|
|
}).catch((error) => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
downloadAsset(type, uuid) {
|
|
return this.currentRegion.caps.downloadAsset(uuid, type);
|
|
}
|
|
uploadAsset(type, data, name, description) {
|
|
return new Promise((resolve, reject) => {
|
|
if (this.agent && this.agent.inventory && this.agent.inventory.main && this.agent.inventory.main.root) {
|
|
this.currentRegion.caps.capsRequestXML('NewFileAgentInventory', {
|
|
'folder_id': new LLSD.UUID(this.agent.inventory.main.root.toString()),
|
|
'asset_type': type,
|
|
'inventory_type': Utils_1.Utils.HTTPAssetTypeToInventoryType(type),
|
|
'name': name,
|
|
'description': description,
|
|
'everyone_mask': (1 << 13) | (1 << 14) | (1 << 15) | (1 << 19),
|
|
'group_mask': (1 << 13) | (1 << 14) | (1 << 15) | (1 << 19),
|
|
'next_owner_mask': (1 << 13) | (1 << 14) | (1 << 15) | (1 << 19),
|
|
'expected_upload_cost': 0
|
|
}).then((response) => {
|
|
if (response['state'] === 'upload') {
|
|
const uploadURL = response['uploader'];
|
|
this.currentRegion.caps.capsRequestUpload(uploadURL, data).then((responseUpload) => {
|
|
resolve(new UUID_1.UUID(responseUpload['new_asset'].toString()));
|
|
}).catch((err) => {
|
|
reject(err);
|
|
});
|
|
}
|
|
}).catch((err) => {
|
|
console.log(err);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
exports.Bot = Bot;
|
|
//# sourceMappingURL=Bot.js.map
|