2145de775b
- Add building support for TaskInventory and nested objects (from XML) - Add support for taking objects into inventory - Add waitForAppearanceSet utility - Add new event for when object is fully resolved (ObjectProperties received) - Fixed InventoryItem CRC method - Fixed quaternion bug - Support for uploading Script, Notecard and Gesture assets - Significantly improved build process
1978 lines
83 KiB
TypeScript
1978 lines
83 KiB
TypeScript
import { CommandsBase } from './CommandsBase';
|
|
import { UUID } from '../UUID';
|
|
import { RegionHandleRequestMessage } from '../messages/RegionHandleRequest';
|
|
import { Message } from '../../enums/Message';
|
|
import { FilterResponse } from '../../enums/FilterResponse';
|
|
import { RegionIDAndHandleReplyMessage } from '../messages/RegionIDAndHandleReply';
|
|
import { ObjectGrabMessage } from '../messages/ObjectGrab';
|
|
import { ObjectDeGrabMessage } from '../messages/ObjectDeGrab';
|
|
import { ObjectGrabUpdateMessage } from '../messages/ObjectGrabUpdate';
|
|
import { ObjectSelectMessage } from '../messages/ObjectSelect';
|
|
import { ObjectPropertiesMessage } from '../messages/ObjectProperties';
|
|
import { Utils } from '../Utils';
|
|
import { ObjectDeselectMessage } from '../messages/ObjectDeselect';
|
|
import { RequestTaskInventoryMessage } from '../messages/RequestTaskInventory';
|
|
import { ReplyTaskInventoryMessage } from '../messages/ReplyTaskInventory';
|
|
import { InventoryItem } from '../InventoryItem';
|
|
import { AssetTypeLL } from '../../enums/AssetTypeLL';
|
|
import { SaleTypeLL } from '../../enums/SaleTypeLL';
|
|
import { InventoryTypeLL } from '../../enums/InventoryTypeLL';
|
|
import { ObjectAddMessage } from '../messages/ObjectAdd';
|
|
import { Quaternion } from '../Quaternion';
|
|
import { RezObjectMessage } from '../messages/RezObject';
|
|
import { PermissionMask } from '../../enums/PermissionMask';
|
|
import { PacketFlags } from '../../enums/PacketFlags';
|
|
import { GameObject } from '../public/GameObject';
|
|
import { PCode } from '../../enums/PCode';
|
|
import { PrimFlags } from '../../enums/PrimFlags';
|
|
import { AssetType } from '../../enums/AssetType';
|
|
import { NewObjectEvent } from '../../events/NewObjectEvent';
|
|
import { Vector3 } from '../Vector3';
|
|
import { Parcel } from '../public/Parcel';
|
|
|
|
import * as Long from 'long';
|
|
import * as micromatch from 'micromatch';
|
|
import * as LLSD from '@caspertech/llsd';
|
|
import { Subject, Subscription } from 'rxjs';
|
|
import { SculptType } from '../..';
|
|
import { ObjectResolvedEvent } from '../../events/ObjectResolvedEvent';
|
|
import { AssetMap } from '../AssetMap';
|
|
import { InventoryType } from '../../enums/InventoryType';
|
|
import { BuildMap } from '../BuildMap';
|
|
import Timer = NodeJS.Timer;
|
|
import Timeout = NodeJS.Timeout;
|
|
|
|
export class RegionCommands extends CommandsBase
|
|
{
|
|
private resolveQueue: {[key: number]: GameObject} = {};
|
|
|
|
async getRegionHandle(regionID: UUID): Promise<Long>
|
|
{
|
|
const circuit = this.currentRegion.circuit;
|
|
const msg: RegionHandleRequestMessage = new RegionHandleRequestMessage();
|
|
msg.RequestBlock = {
|
|
RegionID: regionID,
|
|
};
|
|
circuit.sendMessage(msg, PacketFlags.Reliable);
|
|
const responseMsg: RegionIDAndHandleReplyMessage = await circuit.waitForMessage<RegionIDAndHandleReplyMessage>(Message.RegionIDAndHandleReply, 10000, (filterMsg: RegionIDAndHandleReplyMessage): FilterResponse =>
|
|
{
|
|
if (filterMsg.ReplyBlock.RegionID.toString() === regionID.toString())
|
|
{
|
|
return FilterResponse.Finish;
|
|
}
|
|
else
|
|
{
|
|
return FilterResponse.NoMatch;
|
|
}
|
|
});
|
|
return responseMsg.ReplyBlock.RegionHandle;
|
|
}
|
|
|
|
waitForHandshake(timeout: number = 10000): Promise<void>
|
|
{
|
|
return new Promise((resolve, reject) =>
|
|
{
|
|
if (this.currentRegion.handshakeComplete)
|
|
{
|
|
resolve();
|
|
}
|
|
else
|
|
{
|
|
let handshakeSubscription: Subscription | undefined;
|
|
let timeoutTimer: number | undefined;
|
|
handshakeSubscription = this.currentRegion.handshakeCompleteEvent.subscribe(() =>
|
|
{
|
|
if (timeoutTimer !== undefined)
|
|
{
|
|
clearTimeout(timeoutTimer);
|
|
timeoutTimer = undefined;
|
|
}
|
|
if (handshakeSubscription !== undefined)
|
|
{
|
|
handshakeSubscription.unsubscribe();
|
|
handshakeSubscription = undefined;
|
|
resolve();
|
|
}
|
|
});
|
|
timeoutTimer = setTimeout(() =>
|
|
{
|
|
if (handshakeSubscription !== undefined)
|
|
{
|
|
handshakeSubscription.unsubscribe();
|
|
handshakeSubscription = undefined;
|
|
}
|
|
if (timeoutTimer !== undefined)
|
|
{
|
|
clearTimeout(timeoutTimer);
|
|
timeoutTimer = undefined;
|
|
reject(new Error('Timeout'));
|
|
}
|
|
}, timeout) as any as number;
|
|
if (this.currentRegion.handshakeComplete)
|
|
{
|
|
if (handshakeSubscription !== undefined)
|
|
{
|
|
handshakeSubscription.unsubscribe();
|
|
handshakeSubscription = undefined;
|
|
}
|
|
if (timeoutTimer !== undefined)
|
|
{
|
|
clearTimeout(timeoutTimer);
|
|
timeoutTimer = undefined;
|
|
}
|
|
resolve();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
async deselectObjects(objects: GameObject[])
|
|
{
|
|
// Limit to 255 objects at once
|
|
const selectLimit = 255;
|
|
if (objects.length > selectLimit)
|
|
{
|
|
for (let x = 0; x < objects.length; x += selectLimit)
|
|
{
|
|
const selectList: GameObject[] = [];
|
|
for (let y = 0; y < selectLimit; y++)
|
|
{
|
|
if (y < objects.length)
|
|
{
|
|
selectList.push(objects[x + y]);
|
|
}
|
|
}
|
|
await this.deselectObjects(selectList);
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
const deselectObject = new ObjectDeselectMessage();
|
|
deselectObject.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: this.circuit.sessionID
|
|
};
|
|
deselectObject.ObjectData = [];
|
|
const uuidMap: {[key: string]: GameObject} = {};
|
|
for (const obj of objects)
|
|
{
|
|
const uuidStr = obj.FullID.toString();
|
|
if (!uuidMap[uuidStr])
|
|
{
|
|
uuidMap[uuidStr] = obj;
|
|
deselectObject.ObjectData.push({
|
|
ObjectLocalID: obj.ID
|
|
});
|
|
}
|
|
}
|
|
|
|
// Create a map of our expected UUIDs
|
|
|
|
const sequenceID = this.circuit.sendMessage(deselectObject, PacketFlags.Reliable);
|
|
return await this.circuit.waitForAck(sequenceID, 10000);
|
|
}
|
|
}
|
|
|
|
countObjects(): number
|
|
{
|
|
return this.currentRegion.objects.getNumberOfObjects();
|
|
}
|
|
|
|
getTerrainTextures(): UUID[]
|
|
{
|
|
const textures: UUID[] = [];
|
|
textures.push(this.currentRegion.terrainDetail0);
|
|
textures.push(this.currentRegion.terrainDetail1);
|
|
textures.push(this.currentRegion.terrainDetail2);
|
|
textures.push(this.currentRegion.terrainDetail3);
|
|
return textures;
|
|
}
|
|
|
|
exportSettings(): string
|
|
{
|
|
return this.currentRegion.exportXML();
|
|
}
|
|
|
|
async getTerrain()
|
|
{
|
|
await this.currentRegion.waitForTerrain();
|
|
const buf = Buffer.allocUnsafe(262144);
|
|
let pos = 0;
|
|
for (let x = 0; x < 256; x++)
|
|
{
|
|
for (let y = 0; y < 256; y++)
|
|
{
|
|
buf.writeFloatLE(this.currentRegion.terrain[x][y], pos);
|
|
pos = pos + 4;
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
async selectObjects(objects: GameObject[])
|
|
{
|
|
// Limit to 255 objects at once
|
|
const selectLimit = 255;
|
|
if (objects.length > selectLimit)
|
|
{
|
|
for (let x = 0; x < objects.length; x += selectLimit)
|
|
{
|
|
const selectList: GameObject[] = [];
|
|
for (let y = 0; y < selectLimit; y++)
|
|
{
|
|
if (y < objects.length)
|
|
{
|
|
selectList.push(objects[x + y]);
|
|
}
|
|
}
|
|
await this.selectObjects(selectList);
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
const selectObject = new ObjectSelectMessage();
|
|
selectObject.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: this.circuit.sessionID
|
|
};
|
|
selectObject.ObjectData = [];
|
|
const uuidMap: {[key: string]: GameObject} = {};
|
|
for (const obj of objects)
|
|
{
|
|
const uuidStr = obj.FullID.toString();
|
|
if (!uuidMap[uuidStr])
|
|
{
|
|
uuidMap[uuidStr] = obj;
|
|
selectObject.ObjectData.push({
|
|
ObjectLocalID: obj.ID
|
|
});
|
|
}
|
|
}
|
|
|
|
// Create a map of our expected UUIDs
|
|
let resolved = 0;
|
|
|
|
this.circuit.sendMessage(selectObject, PacketFlags.Reliable);
|
|
const unresolved = [];
|
|
try
|
|
{
|
|
const results = await this.circuit.waitForMessage<ObjectPropertiesMessage>(Message.ObjectProperties, 10000, (propertiesMessage: ObjectPropertiesMessage): FilterResponse =>
|
|
{
|
|
let found = false;
|
|
for (const objData of propertiesMessage.ObjectData)
|
|
{
|
|
const objDataUUID = objData.ObjectID.toString();
|
|
if (uuidMap[objDataUUID] !== undefined)
|
|
{
|
|
resolved++;
|
|
const obj = uuidMap[objDataUUID];
|
|
obj.creatorID = objData.CreatorID;
|
|
obj.creationDate = objData.CreationDate;
|
|
obj.baseMask = objData.BaseMask;
|
|
obj.ownerMask = objData.OwnerMask;
|
|
obj.groupMask = objData.GroupMask;
|
|
obj.everyoneMask = objData.EveryoneMask;
|
|
obj.nextOwnerMask = objData.NextOwnerMask;
|
|
obj.ownershipCost = objData.OwnershipCost;
|
|
obj.saleType = objData.SaleType;
|
|
obj.salePrice = objData.SalePrice;
|
|
obj.aggregatePerms = objData.AggregatePerms;
|
|
obj.aggregatePermTextures = objData.AggregatePermTextures;
|
|
obj.aggregatePermTexturesOwner = objData.AggregatePermTexturesOwner;
|
|
obj.category = objData.Category;
|
|
obj.inventorySerial = objData.InventorySerial;
|
|
obj.itemID = objData.ItemID;
|
|
obj.folderID = objData.FolderID;
|
|
obj.fromTaskID = objData.FromTaskID;
|
|
obj.groupID = objData.GroupID;
|
|
obj.lastOwnerID = objData.LastOwnerID;
|
|
obj.name = Utils.BufferToStringSimple(objData.Name);
|
|
obj.description = Utils.BufferToStringSimple(objData.Description);
|
|
obj.touchName = Utils.BufferToStringSimple(objData.TouchName);
|
|
obj.sitName = Utils.BufferToStringSimple(objData.SitName);
|
|
obj.textureID = Utils.BufferToStringSimple(objData.TextureID);
|
|
obj.resolvedAt = new Date().getTime() / 1000;
|
|
delete uuidMap[objDataUUID];
|
|
found = true;
|
|
}
|
|
}
|
|
if (Object.keys(uuidMap).length === 0)
|
|
{
|
|
return FilterResponse.Finish;
|
|
}
|
|
if (!found)
|
|
{
|
|
return FilterResponse.NoMatch;
|
|
}
|
|
else
|
|
{
|
|
return FilterResponse.Match;
|
|
}
|
|
});
|
|
}
|
|
catch (error)
|
|
{
|
|
|
|
}
|
|
finally
|
|
{
|
|
|
|
for (const obj of objects)
|
|
{
|
|
if (obj.resolvedAt === undefined || obj.name === undefined)
|
|
{
|
|
obj.resolveAttempts++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private parseLine(line: string): {
|
|
'key': string | null,
|
|
'value': string
|
|
}
|
|
{
|
|
line = line.trim().replace(/[\t]/gu, ' ').trim();
|
|
while (line.indexOf('\u0020\u0020') > 0)
|
|
{
|
|
line = line.replace(/\u0020\u0020/gu, '\u0020');
|
|
}
|
|
let key: string | null = null;
|
|
let value = '';
|
|
if (line.length > 2)
|
|
{
|
|
const sep = line.indexOf(' ');
|
|
if (sep > 0)
|
|
{
|
|
key = line.substr(0, sep);
|
|
value = line.substr(sep + 1);
|
|
}
|
|
}
|
|
else if (line.length === 1)
|
|
{
|
|
key = line;
|
|
}
|
|
else if (line.length > 0)
|
|
{
|
|
return {
|
|
'key': line,
|
|
'value': ''
|
|
}
|
|
}
|
|
if (key !== null)
|
|
{
|
|
key = key.trim();
|
|
}
|
|
return {
|
|
'key': key,
|
|
'value': value
|
|
}
|
|
}
|
|
|
|
getName(): string
|
|
{
|
|
return this.currentRegion.regionName;
|
|
}
|
|
|
|
private waitForObjectResolve(localID: number)
|
|
{
|
|
return new Promise((resolve, reject) =>
|
|
{
|
|
let timeout: Timeout | undefined = undefined;
|
|
let subs: Subscription | undefined = undefined;
|
|
try
|
|
{
|
|
const ourObject = this.currentRegion.objects.getObjectByLocalID(localID);
|
|
if (ourObject.resolvedAt)
|
|
{
|
|
resolve();
|
|
return;
|
|
}
|
|
}
|
|
catch (ignore)
|
|
{
|
|
|
|
}
|
|
subs = this.currentRegion.clientEvents.onObjectResolvedEvent.subscribe((evt: ObjectResolvedEvent) =>
|
|
{
|
|
if (evt.object.ID === localID)
|
|
{
|
|
if (timeout !== undefined)
|
|
{
|
|
clearTimeout(timeout);
|
|
timeout = undefined;
|
|
}
|
|
if (subs !== undefined)
|
|
{
|
|
subs.unsubscribe();
|
|
subs = undefined;
|
|
}
|
|
resolve();
|
|
}
|
|
});
|
|
timeout = setTimeout(() =>
|
|
{
|
|
if (timeout !== undefined)
|
|
{
|
|
clearTimeout(timeout);
|
|
timeout = undefined;
|
|
}
|
|
if (subs !== undefined)
|
|
{
|
|
subs.unsubscribe();
|
|
subs = undefined;
|
|
}
|
|
const object = this.currentRegion.objects.getObjectByLocalID(localID);
|
|
if (object.resolvedAt)
|
|
{
|
|
try
|
|
{
|
|
const ourObject = this.currentRegion.objects.getObjectByLocalID(localID);
|
|
if (ourObject.resolvedAt)
|
|
{
|
|
console.warn('Resolve timed out but object ' + localID + ' HAS been resolved!');
|
|
resolve();
|
|
return;
|
|
}
|
|
}
|
|
catch (ignore)
|
|
{
|
|
|
|
}
|
|
}
|
|
reject(new Error('Timeout'));
|
|
}, 10000);
|
|
});
|
|
}
|
|
|
|
private async queueResolveObject(object: GameObject, skipInventory = false)
|
|
{
|
|
if (object.resolvedAt)
|
|
{
|
|
return;
|
|
}
|
|
if (this.resolveQueue[object.ID] === undefined)
|
|
{
|
|
this.resolveQueue[object.ID] = object;
|
|
try
|
|
{
|
|
await this.resolveObjects([object], true, true);
|
|
}
|
|
catch (error)
|
|
{
|
|
console.error('Failed to resolve ' + object.ID);
|
|
}
|
|
delete this.resolveQueue[object.ID];
|
|
}
|
|
else
|
|
{
|
|
return this.waitForObjectResolve(object.ID);
|
|
}
|
|
}
|
|
|
|
private async resolveObjects(objects: GameObject[], onlyUnresolved: boolean = false, skipInventory = false)
|
|
{
|
|
// First, create a map of all object IDs
|
|
const objs: {[key: number]: GameObject} = {};
|
|
const scanObject = function(obj: GameObject)
|
|
{
|
|
const localID = obj.ID;
|
|
if (!objs[localID])
|
|
{
|
|
objs[localID] = obj;
|
|
if (obj.children)
|
|
{
|
|
for (const child of obj.children)
|
|
{
|
|
scanObject(child);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
for (const obj of objects)
|
|
{
|
|
scanObject(obj);
|
|
}
|
|
|
|
const resolveTime = new Date().getTime() / 1000;
|
|
let objectList = [];
|
|
let totalRemaining = 0;
|
|
try
|
|
{
|
|
for (const k of Object.keys(objs))
|
|
{
|
|
const ky = parseInt(k, 10);
|
|
if (objs[ky] !== undefined)
|
|
{
|
|
const o = objs[ky];
|
|
if (o.resolvedAt === undefined)
|
|
{
|
|
o.resolvedAt = 0;
|
|
}
|
|
if (o.resolvedAt !== undefined && o.resolvedAt < resolveTime && o.PCode !== PCode.Avatar && o.resolveAttempts < 3 && (o.Flags === undefined || !(o.Flags & PrimFlags.TemporaryOnRez)))
|
|
{
|
|
totalRemaining++;
|
|
if (!onlyUnresolved || objs[ky].name === undefined)
|
|
{
|
|
objs[ky].name = undefined;
|
|
objectList.push(objs[ky]);
|
|
}
|
|
if (objectList.length > 254)
|
|
{
|
|
try
|
|
{
|
|
await this.selectObjects(objectList);
|
|
await this.deselectObjects(objectList);
|
|
for (const chk of objectList)
|
|
{
|
|
if (chk.resolvedAt !== undefined && chk.resolvedAt >= resolveTime)
|
|
{
|
|
totalRemaining--;
|
|
}
|
|
}
|
|
}
|
|
catch (ignore)
|
|
{
|
|
|
|
}
|
|
finally
|
|
{
|
|
objectList = [];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (objectList.length > 0)
|
|
{
|
|
await this.selectObjects(objectList);
|
|
await this.deselectObjects(objectList);
|
|
for (const chk of objectList)
|
|
{
|
|
if (chk.resolvedAt !== undefined && chk.resolvedAt >= resolveTime)
|
|
{
|
|
totalRemaining --;
|
|
}
|
|
}
|
|
}
|
|
const objectSet = Object.keys(objs);
|
|
let count = 0;
|
|
for (const k of objectSet)
|
|
{
|
|
count++;
|
|
const ky = parseInt(k, 10);
|
|
if (objs[ky] !== undefined && !skipInventory)
|
|
{
|
|
const o = objs[ky];
|
|
if ((o.resolveAttempts === undefined || o.resolveAttempts < 3) && o.FullID !== undefined && o.name !== undefined && o.Flags !== undefined && !(o.Flags & PrimFlags.InventoryEmpty) && (!o.inventory || o.inventory.length === 0))
|
|
{
|
|
const req = new RequestTaskInventoryMessage();
|
|
req.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: this.circuit.sessionID
|
|
};
|
|
req.InventoryData = {
|
|
LocalID: o.ID
|
|
};
|
|
this.circuit.sendMessage(req, PacketFlags.Reliable);
|
|
try
|
|
{
|
|
const inventory = await this.circuit.waitForMessage<ReplyTaskInventoryMessage>(Message.ReplyTaskInventory, 10000, (message: ReplyTaskInventoryMessage): FilterResponse =>
|
|
{
|
|
if (message.InventoryData.TaskID.equals(o.FullID))
|
|
{
|
|
return FilterResponse.Finish;
|
|
}
|
|
else
|
|
{
|
|
return FilterResponse.Match;
|
|
}
|
|
});
|
|
const fileName = Utils.BufferToStringSimple(inventory.InventoryData.Filename);
|
|
|
|
const file = await this.circuit.XferFile(fileName, true, false, UUID.zero(), AssetType.Unknown, true);
|
|
if (file.length === 0)
|
|
{
|
|
o.Flags = o.Flags | PrimFlags.InventoryEmpty;
|
|
}
|
|
else
|
|
{
|
|
let str = file.toString('utf-8');
|
|
let nl = str.indexOf('\0');
|
|
while (nl !== -1)
|
|
{
|
|
str = str.substr(nl + 1);
|
|
nl = str.indexOf('\0')
|
|
}
|
|
const lines: string[] = str.replace(/\r\n/g, '\n').split('\n');
|
|
let lineNum = 0;
|
|
while (lineNum < lines.length)
|
|
{
|
|
let line = lines[lineNum++];
|
|
let result = this.parseLine(line);
|
|
if (result.key !== null)
|
|
{
|
|
switch (result.key)
|
|
{
|
|
case 'inv_object':
|
|
let itemID = UUID.zero();
|
|
let parentID = UUID.zero();
|
|
let name = '';
|
|
let assetType: AssetType = AssetType.Unknown;
|
|
|
|
while (lineNum < lines.length)
|
|
{
|
|
result = this.parseLine(lines[lineNum++]);
|
|
if (result.key !== null)
|
|
{
|
|
if (result.key === '{')
|
|
{
|
|
// do nothing
|
|
}
|
|
else if (result.key === '}')
|
|
{
|
|
break;
|
|
}
|
|
else if (result.key === 'obj_id')
|
|
{
|
|
itemID = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'parent_id')
|
|
{
|
|
parentID = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'type')
|
|
{
|
|
const typeString = result.value as any;
|
|
assetType = parseInt(AssetTypeLL[typeString], 10);
|
|
}
|
|
else if (result.key === 'name')
|
|
{
|
|
name = result.value.substr(0, result.value.indexOf('|'));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (name !== 'Contents')
|
|
{
|
|
console.log('TODO: Do something useful with inv_objects')
|
|
}
|
|
|
|
break;
|
|
case 'inv_item':
|
|
const item: InventoryItem = new InventoryItem();
|
|
while (lineNum < lines.length)
|
|
{
|
|
line = lines[lineNum++];
|
|
result = this.parseLine(line);
|
|
if (result.key !== null)
|
|
{
|
|
if (result.key === '{')
|
|
{
|
|
// do nothing
|
|
}
|
|
else if (result.key === '}')
|
|
{
|
|
break;
|
|
}
|
|
else if (result.key === 'item_id')
|
|
{
|
|
item.itemID = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'parent_id')
|
|
{
|
|
item.parentID = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'permissions')
|
|
{
|
|
while (lineNum < lines.length)
|
|
{
|
|
result = this.parseLine(lines[lineNum++]);
|
|
if (result.key !== null)
|
|
{
|
|
if (result.key === '{')
|
|
{
|
|
// do nothing
|
|
}
|
|
else if (result.key === '}')
|
|
{
|
|
break;
|
|
}
|
|
else if (result.key === 'creator_mask')
|
|
{
|
|
item.permissions.baseMask = parseInt(result.value, 16);
|
|
}
|
|
else if (result.key === 'base_mask')
|
|
{
|
|
item.permissions.baseMask = parseInt(result.value, 16);
|
|
}
|
|
else if (result.key === 'owner_mask')
|
|
{
|
|
item.permissions.ownerMask = parseInt(result.value, 16);
|
|
}
|
|
else if (result.key === 'group_mask')
|
|
{
|
|
item.permissions.groupMask = parseInt(result.value, 16);
|
|
}
|
|
else if (result.key === 'everyone_mask')
|
|
{
|
|
item.permissions.everyoneMask = parseInt(result.value, 16);
|
|
}
|
|
else if (result.key === 'next_owner_mask')
|
|
{
|
|
item.permissions.nextOwnerMask = parseInt(result.value, 16);
|
|
}
|
|
else if (result.key === 'creator_id')
|
|
{
|
|
item.permissions.creator = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'owner_id')
|
|
{
|
|
item.permissions.owner = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'last_owner_id')
|
|
{
|
|
item.permissions.lastOwner = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'group_id')
|
|
{
|
|
item.permissions.group = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'group_owned')
|
|
{
|
|
const val = parseInt(result.value, 10);
|
|
item.permissions.groupOwned = (val !== 0);
|
|
}
|
|
else
|
|
{
|
|
console.log('Unrecognised key (4): ' + result.key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (result.key === 'sale_info')
|
|
{
|
|
while (lineNum < lines.length)
|
|
{
|
|
result = this.parseLine(lines[lineNum++]);
|
|
if (result.key !== null)
|
|
{
|
|
if (result.key === '{')
|
|
{
|
|
// do nothing
|
|
}
|
|
else if (result.key === '}')
|
|
{
|
|
break;
|
|
}
|
|
else if (result.key === 'sale_type')
|
|
{
|
|
const typeString = result.value as any;
|
|
item.saleType = parseInt(SaleTypeLL[typeString], 10);
|
|
}
|
|
else if (result.key === 'sale_price')
|
|
{
|
|
item.salePrice = parseInt(result.value, 10);
|
|
}
|
|
else
|
|
{
|
|
console.log('Unrecognised key (3): ' + result.key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (result.key === 'shadow_id')
|
|
{
|
|
item.assetID = new UUID(result.value).bitwiseOr(new UUID('3c115e51-04f4-523c-9fa6-98aff1034730'));
|
|
}
|
|
else if (result.key === 'asset_id')
|
|
{
|
|
item.assetID = new UUID(result.value);
|
|
}
|
|
else if (result.key === 'type')
|
|
{
|
|
const typeString = result.value as any;
|
|
item.type = parseInt(AssetTypeLL[typeString], 10);
|
|
}
|
|
else if (result.key === 'inv_type')
|
|
{
|
|
const typeString = result.value as any;
|
|
item.inventoryType = parseInt(InventoryTypeLL[typeString], 10);
|
|
}
|
|
else if (result.key === 'flags')
|
|
{
|
|
item.flags = parseInt(result.value, 10);
|
|
}
|
|
else if (result.key === 'name')
|
|
{
|
|
item.name = result.value.substr(0, result.value.indexOf('|'));
|
|
}
|
|
else if (result.key === 'desc')
|
|
{
|
|
item.description = result.value.substr(0, result.value.indexOf('|'));
|
|
}
|
|
else if (result.key === 'creation_date')
|
|
{
|
|
item.created = new Date(parseInt(result.value, 10) * 1000);
|
|
}
|
|
else
|
|
{
|
|
console.log('Unrecognised key (2): ' + result.key);
|
|
}
|
|
}
|
|
}
|
|
o.inventory.push(item);
|
|
break;
|
|
default:
|
|
{
|
|
console.log('Unrecognised task inventory token: [' + result.key + ']');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (error)
|
|
{
|
|
if (o.resolveAttempts === undefined)
|
|
{
|
|
o.resolveAttempts = 0;
|
|
}
|
|
o.resolveAttempts++;
|
|
if (o.FullID !== undefined)
|
|
{
|
|
console.error('Error downloading task inventory of ' + o.FullID.toString() + ':');
|
|
console.error(error);
|
|
}
|
|
else
|
|
{
|
|
console.error('Error downloading task inventory of ' + o.ID + ':');
|
|
console.error(error);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (ignore)
|
|
{
|
|
console.error(ignore);
|
|
}
|
|
finally
|
|
{
|
|
if (totalRemaining < 1)
|
|
{
|
|
totalRemaining = 0;
|
|
for (const obj of objectList)
|
|
{
|
|
if (obj.resolvedAt === undefined || obj.resolvedAt < resolveTime)
|
|
{
|
|
totalRemaining++;
|
|
}
|
|
}
|
|
if (totalRemaining > 0)
|
|
{
|
|
console.error(totalRemaining + ' objects could not be resolved');
|
|
}
|
|
}
|
|
const that = this;
|
|
const getCosts = async function(objIDs: UUID[])
|
|
{
|
|
const result = await that.currentRegion.caps.capsPostXML('GetObjectCost', {
|
|
'object_ids': objIDs
|
|
});
|
|
const uuids = Object.keys(result);
|
|
for (const key of uuids)
|
|
{
|
|
const costs = result[key];
|
|
try
|
|
{
|
|
const obj: GameObject = that.currentRegion.objects.getObjectByUUID(new UUID(key));
|
|
obj.linkPhysicsImpact = parseFloat(costs['linked_set_physics_cost']);
|
|
obj.linkResourceImpact = parseFloat(costs['linked_set_resource_cost']);
|
|
obj.physicaImpact = parseFloat(costs['physics_cost']);
|
|
obj.resourceImpact = parseFloat(costs['resource_cost']);
|
|
obj.limitingType = costs['resource_limiting_type'];
|
|
|
|
|
|
obj.landImpact = Math.round(obj.linkPhysicsImpact);
|
|
if (obj.linkResourceImpact > obj.linkPhysicsImpact)
|
|
{
|
|
obj.landImpact = Math.round(obj.linkResourceImpact);
|
|
}
|
|
obj.calculatedLandImpact = obj.landImpact;
|
|
if (obj.Flags !== undefined && obj.Flags & PrimFlags.TemporaryOnRez && obj.limitingType === 'legacy')
|
|
{
|
|
obj.calculatedLandImpact = 0;
|
|
}
|
|
}
|
|
catch (error)
|
|
{}
|
|
}
|
|
};
|
|
|
|
let ids: UUID[] = [];
|
|
const promises: Promise<void>[] = [];
|
|
for (const obj of objects)
|
|
{
|
|
if (!onlyUnresolved || obj.landImpact === undefined)
|
|
{
|
|
ids.push(new LLSD.UUID(obj.FullID));
|
|
}
|
|
if (ids.length > 255)
|
|
{
|
|
promises.push(getCosts(ids));
|
|
ids = [];
|
|
}
|
|
}
|
|
if (ids.length > 0)
|
|
{
|
|
promises.push(getCosts(ids));
|
|
}
|
|
await Promise.all(promises);
|
|
}
|
|
}
|
|
|
|
private waitForObjectByLocalID(localID: number, timeout: number): Promise<GameObject>
|
|
{
|
|
return new Promise<GameObject>((resolve, reject) =>
|
|
{
|
|
let tmr: Timer | null = null;
|
|
const subscription = this.currentRegion.clientEvents.onNewObjectEvent.subscribe(async (event: NewObjectEvent) =>
|
|
{
|
|
if (event.localID === localID)
|
|
{
|
|
if (tmr !== null)
|
|
{
|
|
clearTimeout(tmr);
|
|
}
|
|
subscription.unsubscribe();
|
|
resolve(event.object);
|
|
}
|
|
});
|
|
tmr = setTimeout(() =>
|
|
{
|
|
subscription.unsubscribe();
|
|
reject(new Error('Timeout'));
|
|
}, timeout)
|
|
});
|
|
}
|
|
|
|
private waitForObjectByUUID(objectID: UUID, timeout: number): Promise<GameObject>
|
|
{
|
|
return new Promise<GameObject>((resolve, reject) =>
|
|
{
|
|
let tmr: Timer | null = null;
|
|
const subscription = this.currentRegion.clientEvents.onNewObjectEvent.subscribe(async (event: NewObjectEvent) =>
|
|
{
|
|
if (event.objectID.equals(objectID))
|
|
{
|
|
if (tmr !== null)
|
|
{
|
|
clearTimeout(tmr);
|
|
}
|
|
subscription.unsubscribe();
|
|
resolve(event.object);
|
|
}
|
|
});
|
|
tmr = setTimeout(() =>
|
|
{
|
|
subscription.unsubscribe();
|
|
reject(new Error('Timeout'));
|
|
}, timeout)
|
|
});
|
|
}
|
|
|
|
private async buildPart(obj: GameObject, posOffset: Vector3, rotOffset: Quaternion, buildMap: BuildMap)
|
|
{
|
|
// Calculate geometry
|
|
const objectPosition = new Vector3(obj.Position);
|
|
const objectRotation = new Quaternion(obj.Rotation);
|
|
const objectScale = new Vector3(obj.Scale);
|
|
|
|
let finalPos = Vector3.getZero();
|
|
let finalRot = Quaternion.getIdentity();
|
|
if (posOffset.x === 0.0 && posOffset.y === 0.0 && posOffset.z === 0.0 && objectPosition !== undefined)
|
|
{
|
|
finalPos = new Vector3(objectPosition);
|
|
finalRot = new Quaternion(objectRotation);
|
|
}
|
|
else
|
|
{
|
|
const adjustedPos = new Vector3(objectPosition).multiplyByQuat(new Quaternion(rotOffset));
|
|
finalPos = new Vector3(new Vector3(posOffset).add(adjustedPos));
|
|
|
|
const baseRot = new Quaternion(rotOffset);
|
|
finalRot = new Quaternion(baseRot.multiply(new Quaternion(objectRotation)));
|
|
}
|
|
|
|
// Is this a mesh part?
|
|
let object: GameObject | null = null;
|
|
if (obj.extraParams !== undefined && obj.extraParams.meshData !== null)
|
|
{
|
|
if (buildMap.assetMap.mesh[obj.extraParams.meshData.meshData.toString()] !== undefined)
|
|
{
|
|
const meshEntry = buildMap.assetMap.mesh[obj.extraParams.meshData.meshData.toString()];
|
|
const rezLocation = new Vector3(buildMap.rezLocation);
|
|
rezLocation.z += (objectScale.z / 2);
|
|
|
|
object = await this.rezFromInventory(obj, rezLocation, new UUID(meshEntry.assetID));
|
|
}
|
|
}
|
|
else if (buildMap.primReservoir.length > 0)
|
|
{
|
|
const newPrim = buildMap.primReservoir.shift();
|
|
if (newPrim !== undefined)
|
|
{
|
|
object = newPrim;
|
|
await object.setShape(
|
|
obj.PathCurve,
|
|
obj.ProfileCurve,
|
|
obj.PathBegin,
|
|
obj.PathEnd,
|
|
obj.PathScaleX,
|
|
obj.PathScaleY,
|
|
obj.PathShearX,
|
|
obj.PathShearY,
|
|
obj.PathTwist,
|
|
obj.PathTwistBegin,
|
|
obj.PathRadiusOffset,
|
|
obj.PathTaperX,
|
|
obj.PathTaperY,
|
|
obj.PathRevolutions,
|
|
obj.PathSkew,
|
|
obj.ProfileBegin,
|
|
obj.ProfileEnd,
|
|
obj.ProfileHollow
|
|
);
|
|
}
|
|
}
|
|
|
|
if (object === null)
|
|
{
|
|
throw new Error('Failed to acquire prim for build');
|
|
}
|
|
|
|
await object.setGeometry(finalPos, finalRot, objectScale);
|
|
|
|
if (obj.extraParams.sculptData !== null)
|
|
{
|
|
if (obj.extraParams.sculptData.type !== SculptType.Mesh)
|
|
{
|
|
const oldTextureID = obj.extraParams.sculptData.texture.toString();
|
|
if (buildMap.assetMap.textures[oldTextureID] !== undefined)
|
|
{
|
|
obj.extraParams.sculptData.texture = new UUID(buildMap.assetMap.textures[oldTextureID]);
|
|
}
|
|
}
|
|
}
|
|
await object.setExtraParams(obj.extraParams);
|
|
|
|
if (obj.TextureEntry !== undefined)
|
|
{
|
|
if (obj.TextureEntry.defaultTexture !== null)
|
|
{
|
|
const oldTextureID = obj.TextureEntry.defaultTexture.textureID.toString();
|
|
if (buildMap.assetMap.textures[oldTextureID] !== undefined)
|
|
{
|
|
obj.TextureEntry.defaultTexture.textureID = new UUID(buildMap.assetMap.textures[oldTextureID]);
|
|
}
|
|
}
|
|
for (const j of obj.TextureEntry.faces)
|
|
{
|
|
const oldTextureID = j.textureID.toString();
|
|
if (buildMap.assetMap.textures[oldTextureID] !== undefined)
|
|
{
|
|
j.textureID = new UUID(buildMap.assetMap.textures[oldTextureID]);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
await object.setTextureEntry(obj.TextureEntry);
|
|
}
|
|
catch (error)
|
|
{
|
|
console.error(error);
|
|
}
|
|
}
|
|
|
|
if (obj.name !== undefined)
|
|
{
|
|
await object.setName(obj.name);
|
|
}
|
|
|
|
if (obj.description !== undefined)
|
|
{
|
|
await object.setDescription(obj.description);
|
|
}
|
|
|
|
for (const invItem of obj.inventory)
|
|
{
|
|
try
|
|
{
|
|
switch (invItem.inventoryType)
|
|
{
|
|
case InventoryType.Clothing:
|
|
{
|
|
if (buildMap.assetMap.clothing[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const invItemID = buildMap.assetMap.clothing[invItem.assetID.toString()];
|
|
await object.dropInventoryIntoContents(new UUID(invItemID));
|
|
}
|
|
break;
|
|
}
|
|
case InventoryType.Bodypart:
|
|
{
|
|
if (buildMap.assetMap.bodyparts[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const invItemID = buildMap.assetMap.bodyparts[invItem.assetID.toString()];
|
|
await object.dropInventoryIntoContents(new UUID(invItemID));
|
|
}
|
|
break;
|
|
}
|
|
case InventoryType.Notecard:
|
|
{
|
|
if (buildMap.assetMap.notecards[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const invItemID = buildMap.assetMap.notecards[invItem.assetID.toString()];
|
|
await object.dropInventoryIntoContents(new UUID(invItemID));
|
|
}
|
|
break;
|
|
}
|
|
case InventoryType.Sound:
|
|
{
|
|
if (buildMap.assetMap.sounds[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const invItemID = buildMap.assetMap.sounds[invItem.assetID.toString()];
|
|
await object.dropInventoryIntoContents(new UUID(invItemID));
|
|
}
|
|
break;
|
|
}
|
|
case InventoryType.Gesture:
|
|
{
|
|
if (buildMap.assetMap.gestures[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const invItemID = buildMap.assetMap.gestures[invItem.assetID.toString()];
|
|
await object.dropInventoryIntoContents(new UUID(invItemID));
|
|
}
|
|
break;
|
|
}
|
|
case InventoryType.Landmark:
|
|
{
|
|
if (buildMap.assetMap.landmarks[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const invItemID = buildMap.assetMap.landmarks[invItem.assetID.toString()];
|
|
await object.dropInventoryIntoContents(new UUID(invItemID));
|
|
}
|
|
break;
|
|
}
|
|
case InventoryType.LSL:
|
|
{
|
|
if (buildMap.assetMap.scripts[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const invItemID = buildMap.assetMap.scripts[invItem.assetID.toString()];
|
|
await object.dropInventoryIntoContents(new UUID(invItemID));
|
|
}
|
|
break;
|
|
}
|
|
case InventoryType.Animation:
|
|
{
|
|
if (buildMap.assetMap.animations[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const invItemID = buildMap.assetMap.animations[invItem.assetID.toString()];
|
|
await object.dropInventoryIntoContents(new UUID(invItemID));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (error)
|
|
{
|
|
console.error(error);
|
|
}
|
|
}
|
|
|
|
// Do nested objects last
|
|
for (const invItem of obj.inventory)
|
|
{
|
|
try
|
|
{
|
|
switch (invItem.inventoryType)
|
|
{
|
|
case InventoryType.Object:
|
|
{
|
|
if (buildMap.assetMap.objects[invItem.assetID.toString()] !== undefined)
|
|
{
|
|
const objectXML = buildMap.assetMap.objects[invItem.assetID.toString()];
|
|
if (objectXML !== null)
|
|
{
|
|
const taskObjectXML = await GameObject.fromXML(objectXML.toString('utf-8'));
|
|
const taskObject = await this.buildObjectNew(taskObjectXML, buildMap.callback, buildMap.costOnly);
|
|
if (taskObject !== null)
|
|
{
|
|
const invItemUUID = await taskObject.takeToInventory();
|
|
await object.dropInventoryIntoContents(invItemUUID);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (error)
|
|
{
|
|
console.error(error);
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
|
|
private gatherAssets(obj: GameObject, buildMap: BuildMap)
|
|
{
|
|
if (obj.extraParams !== undefined)
|
|
{
|
|
if (obj.extraParams.meshData !== null)
|
|
{
|
|
buildMap.assetMap.mesh[obj.extraParams.meshData.meshData.toString()] = {
|
|
objectName: obj.name || 'Object',
|
|
objectDescription: obj.description || '(no description)',
|
|
assetID: obj.extraParams.meshData.meshData.toString()
|
|
};
|
|
}
|
|
else
|
|
{
|
|
buildMap.primsNeeded++;
|
|
}
|
|
if (obj.extraParams.sculptData !== null)
|
|
{
|
|
if (obj.extraParams.sculptData.type !== SculptType.Mesh)
|
|
{
|
|
buildMap.assetMap.textures[obj.extraParams.sculptData.texture.toString()] = obj.extraParams.sculptData.texture.toString();
|
|
}
|
|
}
|
|
if (obj.TextureEntry !== undefined)
|
|
{
|
|
for (const j of obj.TextureEntry.faces)
|
|
{
|
|
const textureID = j.textureID;
|
|
buildMap.assetMap.textures[textureID.toString()] = textureID.toString();
|
|
}
|
|
if (obj.TextureEntry.defaultTexture !== null)
|
|
{
|
|
const textureID = obj.TextureEntry.defaultTexture.textureID;
|
|
buildMap.assetMap.textures[textureID.toString()] = textureID.toString();
|
|
}
|
|
}
|
|
if (obj.inventory !== undefined)
|
|
{
|
|
for (const j of obj.inventory)
|
|
{
|
|
switch (j.inventoryType)
|
|
{
|
|
case InventoryType.Animation:
|
|
{
|
|
buildMap.assetMap.animations[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.Bodypart:
|
|
{
|
|
buildMap.assetMap.bodyparts[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.CallingCard:
|
|
{
|
|
buildMap.assetMap.callingcards[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.Clothing:
|
|
{
|
|
buildMap.assetMap.clothing[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.Gesture:
|
|
{
|
|
buildMap.assetMap.gestures[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.Landmark:
|
|
{
|
|
buildMap.assetMap.landmarks[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.LSL:
|
|
{
|
|
buildMap.assetMap.scripts[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.Snapshot:
|
|
{
|
|
buildMap.assetMap.textures[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.Notecard:
|
|
{
|
|
buildMap.assetMap.notecards[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.Sound:
|
|
{
|
|
buildMap.assetMap.sounds[j.assetID.toString()] = j.assetID.toString();
|
|
break;
|
|
}
|
|
case InventoryType.Object:
|
|
{
|
|
buildMap.assetMap.objects[j.assetID.toString()] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (obj.children)
|
|
{
|
|
for (const child of obj.children)
|
|
{
|
|
this.gatherAssets(child, buildMap);
|
|
}
|
|
}
|
|
}
|
|
|
|
async buildObjectNew(obj: GameObject, callback: (map: AssetMap) => void, costOnly: boolean = false): Promise<GameObject | null>
|
|
{
|
|
const map: AssetMap = new AssetMap();
|
|
const buildMap = new BuildMap(map, callback, costOnly);
|
|
this.gatherAssets(obj, buildMap);
|
|
await callback(map);
|
|
|
|
if (costOnly)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
let agentPos = new Vector3([128, 128, 2048]);
|
|
try
|
|
{
|
|
const agentLocalID = this.currentRegion.agent.localID;
|
|
const agentObject = this.currentRegion.objects.getObjectByLocalID(agentLocalID);
|
|
if (agentObject.Position !== undefined)
|
|
{
|
|
agentPos = new Vector3(agentObject.Position);
|
|
}
|
|
else
|
|
{
|
|
throw new Error('Agent position is undefined');
|
|
}
|
|
}
|
|
catch (error)
|
|
{
|
|
console.warn('Unable to find avatar location, rezzing at ' + agentPos.toString());
|
|
}
|
|
agentPos.z += 2.0;
|
|
buildMap.rezLocation = agentPos;
|
|
// Set camera above target location for fast acquisition
|
|
const campos = new Vector3(agentPos);
|
|
campos.z += 2.0;
|
|
await this.currentRegion.clientCommands.agent.setCamera(campos, agentPos, 10, new Vector3([-1.0, 0, 0]), new Vector3([0.0, 1.0, 0]));
|
|
|
|
if (buildMap.primsNeeded > 0)
|
|
{
|
|
buildMap.primReservoir = await this.createPrims(buildMap.primsNeeded, agentPos);
|
|
}
|
|
|
|
const parts = [];
|
|
parts.push(this.buildPart(obj, Vector3.getZero(), Quaternion.getIdentity(), buildMap));
|
|
|
|
if (obj.children)
|
|
{
|
|
if (obj.Position === undefined)
|
|
{
|
|
obj.Position = Vector3.getZero();
|
|
}
|
|
if (obj.Rotation === undefined)
|
|
{
|
|
obj.Rotation = Quaternion.getIdentity();
|
|
}
|
|
for (const child of obj.children)
|
|
{
|
|
if (child.Position !== undefined && child.Rotation !== undefined)
|
|
{
|
|
const objPos = new Vector3(obj.Position);
|
|
const objRot = new Quaternion(obj.Rotation);
|
|
parts.push(this.buildPart(child, objPos, objRot, buildMap));
|
|
}
|
|
}
|
|
}
|
|
const results: GameObject[] = await Promise.all(parts);
|
|
|
|
const rootObj = results[0];
|
|
const childPrims: GameObject[] = [];
|
|
for (const childObject of results)
|
|
{
|
|
if (childObject !== rootObj)
|
|
{
|
|
childPrims.push(childObject);
|
|
}
|
|
}
|
|
await rootObj.linkFrom(childPrims);
|
|
return rootObj;
|
|
}
|
|
|
|
private createPrims(count: number, position: Vector3)
|
|
{
|
|
return new Promise<GameObject[]>((resolve, reject) =>
|
|
{
|
|
const gatheredPrims: GameObject[] = [];
|
|
let objSub: Subscription | undefined = undefined;
|
|
let timeout: Timeout | undefined = setTimeout(() =>
|
|
{
|
|
if (objSub !== undefined)
|
|
{
|
|
objSub.unsubscribe();
|
|
objSub = undefined;
|
|
}
|
|
if (timeout !== undefined)
|
|
{
|
|
clearTimeout(timeout);
|
|
timeout = undefined;
|
|
}
|
|
reject(new Error('Failed to gather ' + count + ' prims - only gathered ' + gatheredPrims.length));
|
|
}, 30000);
|
|
objSub = this.currentRegion.clientEvents.onNewObjectEvent.subscribe(async (evt: NewObjectEvent) =>
|
|
{
|
|
if (!evt.object.resolvedAt)
|
|
{
|
|
// We need to get the full ObjectProperties so we can be sure this is or isn't a rez from inventory
|
|
await this.queueResolveObject(evt.object, true);
|
|
}
|
|
if (evt.createSelected && !evt.object.claimedForBuild)
|
|
{
|
|
if (evt.object.itemID === undefined || evt.object.itemID.equals(UUID.zero()))
|
|
{
|
|
if (
|
|
evt.object.PCode === PCode.Prim &&
|
|
evt.object.Material === 3 &&
|
|
evt.object.PathCurve === 16 &&
|
|
evt.object.ProfileCurve === 1 &&
|
|
evt.object.PathBegin === 0 &&
|
|
evt.object.PathEnd === 1 &&
|
|
evt.object.PathScaleX === 1 &&
|
|
evt.object.PathScaleY === 1 &&
|
|
evt.object.PathShearX === 0 &&
|
|
evt.object.PathShearY === 0 &&
|
|
evt.object.PathTwist === 0 &&
|
|
evt.object.PathTwistBegin === 0 &&
|
|
evt.object.PathRadiusOffset === 0 &&
|
|
evt.object.PathTaperX === 0 &&
|
|
evt.object.PathTaperY === 0 &&
|
|
evt.object.PathRevolutions === 1 &&
|
|
evt.object.PathSkew === 0 &&
|
|
evt.object.ProfileBegin === 0 &&
|
|
evt.object.ProfileHollow === 0
|
|
)
|
|
{
|
|
evt.object.claimedForBuild = true;
|
|
gatheredPrims.push(evt.object);
|
|
if (gatheredPrims.length === count)
|
|
{
|
|
if (objSub !== undefined)
|
|
{
|
|
objSub.unsubscribe();
|
|
objSub = undefined;
|
|
}
|
|
if (timeout !== undefined)
|
|
{
|
|
clearTimeout(timeout);
|
|
timeout = undefined;
|
|
}
|
|
resolve(gatheredPrims);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
for (let x = 0; x < count; x++)
|
|
{
|
|
const msg = new ObjectAddMessage();
|
|
msg.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: this.circuit.sessionID,
|
|
GroupID: UUID.zero()
|
|
};
|
|
msg.ObjectData = {
|
|
PCode: PCode.Prim,
|
|
Material: 3,
|
|
AddFlags: PrimFlags.CreateSelected,
|
|
PathCurve: 16,
|
|
ProfileCurve: 1,
|
|
PathBegin: 0,
|
|
PathEnd: 0,
|
|
PathScaleX: 100,
|
|
PathScaleY: 100,
|
|
PathShearX: 0,
|
|
PathShearY: 0,
|
|
PathTwist: 0,
|
|
PathTwistBegin: 0,
|
|
PathRadiusOffset: 0,
|
|
PathTaperX: 0,
|
|
PathTaperY: 0,
|
|
PathRevolutions: 0,
|
|
PathSkew: 0,
|
|
ProfileBegin: 0,
|
|
ProfileEnd: 0,
|
|
ProfileHollow: 0,
|
|
BypassRaycast: 1,
|
|
RayStart: position,
|
|
RayEnd: position,
|
|
RayTargetID: UUID.zero(),
|
|
RayEndIsIntersection: 0,
|
|
Scale: new Vector3([0.5, 0.5, 0.5]),
|
|
Rotation: Quaternion.getIdentity(),
|
|
State: 0
|
|
};
|
|
this.circuit.sendMessage(msg, PacketFlags.Reliable);
|
|
}
|
|
});
|
|
}
|
|
|
|
rezFromInventory(obj: GameObject, position: Vector3, inventoryID: UUID): Promise<GameObject>
|
|
{
|
|
return new Promise(async (resolve, reject) =>
|
|
{
|
|
const invItem = this.agent.inventory.itemsByID[inventoryID.toString()];
|
|
const queryID = UUID.random();
|
|
const msg = new RezObjectMessage();
|
|
msg.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: this.circuit.sessionID,
|
|
GroupID: UUID.zero()
|
|
};
|
|
msg.RezData = {
|
|
FromTaskID: UUID.zero(),
|
|
BypassRaycast: 1,
|
|
RayStart: position,
|
|
RayEnd: position,
|
|
RayTargetID: UUID.zero(),
|
|
RayEndIsIntersection: false,
|
|
RezSelected: true,
|
|
RemoveItem: false,
|
|
ItemFlags: invItem.flags,
|
|
GroupMask: PermissionMask.All,
|
|
EveryoneMask: PermissionMask.All,
|
|
NextOwnerMask: PermissionMask.All,
|
|
};
|
|
msg.InventoryData = {
|
|
ItemID: invItem.itemID,
|
|
FolderID: invItem.parentID,
|
|
CreatorID: invItem.permissions.creator,
|
|
OwnerID: invItem.permissions.owner,
|
|
GroupID: invItem.permissions.group,
|
|
BaseMask: invItem.permissions.baseMask,
|
|
OwnerMask: invItem.permissions.ownerMask,
|
|
GroupMask: invItem.permissions.groupMask,
|
|
EveryoneMask: invItem.permissions.everyoneMask,
|
|
NextOwnerMask: invItem.permissions.nextOwnerMask,
|
|
GroupOwned: false,
|
|
TransactionID: queryID,
|
|
Type: invItem.type,
|
|
InvType: invItem.inventoryType,
|
|
Flags: invItem.flags,
|
|
SaleType: invItem.saleType,
|
|
SalePrice: invItem.salePrice,
|
|
Name: Utils.StringToBuffer(invItem.name),
|
|
Description: Utils.StringToBuffer(invItem.description),
|
|
CreationDate: Math.round(invItem.created.getTime() / 1000),
|
|
CRC: 0,
|
|
};
|
|
|
|
let objSub: Subscription | undefined = undefined;
|
|
let timeout: Timeout | undefined = setTimeout(() =>
|
|
{
|
|
if (objSub !== undefined)
|
|
{
|
|
objSub.unsubscribe();
|
|
objSub = undefined;
|
|
}
|
|
if (timeout !== undefined)
|
|
{
|
|
clearTimeout(timeout);
|
|
timeout = undefined;
|
|
}
|
|
reject(new Error('Prim never arrived'));
|
|
}, 10000);
|
|
let claimedPrim = false;
|
|
objSub = this.currentRegion.clientEvents.onNewObjectEvent.subscribe(async (evt: NewObjectEvent) =>
|
|
{
|
|
if (evt.createSelected && !evt.object.resolvedAt)
|
|
{
|
|
// We need to get the full ObjectProperties so we can be sure this is or isn't a rez from inventory
|
|
await this.queueResolveObject(evt.object, true);
|
|
}
|
|
if (evt.createSelected && !evt.object.claimedForBuild && !claimedPrim)
|
|
{
|
|
if (inventoryID !== undefined && evt.object.itemID !== undefined && evt.object.itemID.equals(inventoryID))
|
|
{
|
|
if (objSub !== undefined)
|
|
{
|
|
objSub.unsubscribe();
|
|
objSub = undefined;
|
|
}
|
|
if (timeout !== undefined)
|
|
{
|
|
clearTimeout(timeout);
|
|
timeout = undefined;
|
|
}
|
|
evt.object.claimedForBuild = true;
|
|
claimedPrim = true;
|
|
resolve(evt.object);
|
|
}
|
|
}
|
|
});
|
|
|
|
// Move the camera to look directly at prim for faster capture
|
|
if (obj.Scale !== undefined)
|
|
{
|
|
const camLocation = new Vector3(position);
|
|
camLocation.z += (obj.Scale.z / 2) + 1;
|
|
await this.currentRegion.clientCommands.agent.setCamera(camLocation, position, obj.Scale.z, new Vector3([-1.0, 0, 0]), new Vector3([0.0, 1.0, 0]));
|
|
}
|
|
this.circuit.sendMessage(msg, PacketFlags.Reliable);
|
|
});
|
|
}
|
|
|
|
async getObjectByLocalID(id: number, resolve: boolean, waitFor: number = 0)
|
|
{
|
|
let obj = null;
|
|
try
|
|
{
|
|
obj = this.currentRegion.objects.getObjectByLocalID(id);
|
|
}
|
|
catch (error)
|
|
{
|
|
if (waitFor > 0)
|
|
{
|
|
obj = await this.waitForObjectByLocalID(id, waitFor);
|
|
}
|
|
else
|
|
{
|
|
throw(error);
|
|
}
|
|
}
|
|
if (resolve)
|
|
{
|
|
await this.resolveObjects([obj]);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
async getObjectByUUID(id: UUID, resolve: boolean, waitFor: number = 0)
|
|
{
|
|
let obj = null;
|
|
try
|
|
{
|
|
obj = this.currentRegion.objects.getObjectByUUID(id);
|
|
}
|
|
catch (error)
|
|
{
|
|
if (waitFor > 0)
|
|
{
|
|
obj = await this.waitForObjectByUUID(id, waitFor);
|
|
}
|
|
else
|
|
{
|
|
throw(error);
|
|
}
|
|
}
|
|
if (resolve)
|
|
{
|
|
await this.resolveObjects([obj]);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
async findObjectsByName(pattern: string | RegExp, minX?: number, maxX?: number, minY?: number, maxY?: number, minZ?: number, maxZ?: number): Promise<GameObject[]>
|
|
{
|
|
let objects: GameObject[] = [];
|
|
if (minX !== undefined && maxX !== undefined && minY !== undefined && maxY !== undefined && minZ !== undefined && maxZ !== undefined)
|
|
{
|
|
objects = await this.getObjectsInArea(minX, maxX, minY, maxY, minZ, maxZ, true);
|
|
}
|
|
else
|
|
{
|
|
objects = await this.getAllObjects(true);
|
|
}
|
|
const idCheck: {[key: string]: boolean} = {};
|
|
const matches: GameObject[] = [];
|
|
const it = function(go: GameObject)
|
|
{
|
|
if (go.name !== undefined)
|
|
{
|
|
let match = false;
|
|
if (pattern instanceof RegExp)
|
|
{
|
|
if (pattern.test(go.name))
|
|
{
|
|
match = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
match = micromatch.isMatch(go.name, pattern, {nocase: true});
|
|
}
|
|
|
|
if (match)
|
|
{
|
|
const fullID = go.FullID.toString();
|
|
if (!idCheck[fullID])
|
|
{
|
|
matches.push(go);
|
|
idCheck[fullID] = true;
|
|
}
|
|
}
|
|
}
|
|
if (go.children && go.children.length > 0)
|
|
{
|
|
for (const child of go.children)
|
|
{
|
|
it(child);
|
|
}
|
|
}
|
|
};
|
|
for (const go of objects)
|
|
{
|
|
it(go);
|
|
}
|
|
return matches;
|
|
}
|
|
|
|
getParcelAt(x: number, y: number): Promise<Parcel>
|
|
{
|
|
return this.currentRegion.getParcelProperties(x, y);
|
|
}
|
|
|
|
getParcels(): Promise<Parcel[]>
|
|
{
|
|
return this.currentRegion.getParcels();
|
|
}
|
|
|
|
async getAllObjects(resolve: boolean = false, onlyUnresolved: boolean = false): Promise<GameObject[]>
|
|
{
|
|
const objs = await this.currentRegion.objects.getAllObjects();
|
|
if (resolve)
|
|
{
|
|
await this.resolveObjects(objs, onlyUnresolved);
|
|
}
|
|
return objs;
|
|
}
|
|
|
|
async getObjectsInArea(minX: number, maxX: number, minY: number, maxY: number, minZ: number, maxZ: number, resolve: boolean = false): Promise<GameObject[]>
|
|
{
|
|
const objs = await this.currentRegion.objects.getObjectsInArea(minX, maxX, minY, maxY, minZ, maxZ);
|
|
if (resolve)
|
|
{
|
|
await this.resolveObjects(objs);
|
|
}
|
|
return objs;
|
|
}
|
|
|
|
async pruneObjects(checkList: GameObject[]): Promise<GameObject[]>
|
|
{
|
|
let uuids = [];
|
|
let objects = [];
|
|
const stillAlive: {[key: string]: GameObject} = {};
|
|
const checkObjects = async (uuidList: any[], objectList: GameObject[]) =>
|
|
{
|
|
|
|
const objRef: {[key: string]: GameObject} = {};
|
|
for (const obj of objectList)
|
|
{
|
|
objRef[obj.FullID.toString()] = obj;
|
|
}
|
|
const result = await this.currentRegion.caps.capsPostXML('GetObjectCost', {
|
|
'object_ids': uuidList
|
|
});
|
|
for (const u of Object.keys(result))
|
|
{
|
|
stillAlive[u] = objRef[u];
|
|
}
|
|
};
|
|
|
|
for (const o of checkList)
|
|
{
|
|
if (o.FullID)
|
|
{
|
|
uuids.push(new LLSD.UUID(o.FullID));
|
|
objects.push(o);
|
|
if (uuids.length > 256)
|
|
{
|
|
await checkObjects(uuids, objects);
|
|
uuids = [];
|
|
objects = [];
|
|
}
|
|
}
|
|
}
|
|
if (uuids.length > 0)
|
|
{
|
|
await checkObjects(uuids, objects);
|
|
}
|
|
const deadObjects: GameObject[] = [];
|
|
for (const o of checkList)
|
|
{
|
|
let found = false;
|
|
if (o.FullID)
|
|
{
|
|
const fullID = o.FullID.toString();
|
|
if (stillAlive[fullID])
|
|
{
|
|
found = true;
|
|
}
|
|
}
|
|
if (!found)
|
|
{
|
|
deadObjects.push(o);
|
|
}
|
|
}
|
|
return deadObjects;
|
|
}
|
|
|
|
setPersist(persist: boolean)
|
|
{
|
|
this.currentRegion.objects.setPersist(persist);
|
|
}
|
|
|
|
async grabObject(localID: number | UUID,
|
|
grabOffset: Vector3 = Vector3.getZero(),
|
|
uvCoordinate: Vector3 = Vector3.getZero(),
|
|
stCoordinate: Vector3 = Vector3.getZero(),
|
|
faceIndex: number = 0,
|
|
position: Vector3 = Vector3.getZero(),
|
|
normal: Vector3 = Vector3.getZero(),
|
|
binormal: Vector3 = Vector3.getZero())
|
|
{
|
|
if (localID instanceof UUID)
|
|
{
|
|
const obj: GameObject = this.currentRegion.objects.getObjectByUUID(localID);
|
|
localID = obj.ID;
|
|
}
|
|
const msg = new ObjectGrabMessage();
|
|
msg.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: this.circuit.sessionID
|
|
};
|
|
msg.ObjectData = {
|
|
LocalID: localID,
|
|
GrabOffset: grabOffset
|
|
};
|
|
msg.SurfaceInfo = [
|
|
{
|
|
UVCoord: uvCoordinate,
|
|
STCoord: stCoordinate,
|
|
FaceIndex: faceIndex,
|
|
Position: position,
|
|
Normal: normal,
|
|
Binormal: binormal
|
|
}
|
|
];
|
|
const seqID = this.circuit.sendMessage(msg, PacketFlags.Reliable);
|
|
await this.circuit.waitForAck(seqID, 10000);
|
|
}
|
|
|
|
async deGrabObject(localID: number | UUID,
|
|
grabOffset: Vector3 = Vector3.getZero(),
|
|
uvCoordinate: Vector3 = Vector3.getZero(),
|
|
stCoordinate: Vector3 = Vector3.getZero(),
|
|
faceIndex: number = 0,
|
|
position: Vector3 = Vector3.getZero(),
|
|
normal: Vector3 = Vector3.getZero(),
|
|
binormal: Vector3 = Vector3.getZero())
|
|
{
|
|
if (localID instanceof UUID)
|
|
{
|
|
const obj: GameObject = this.currentRegion.objects.getObjectByUUID(localID);
|
|
localID = obj.ID;
|
|
}
|
|
const msg = new ObjectDeGrabMessage();
|
|
msg.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: this.circuit.sessionID
|
|
};
|
|
msg.ObjectData = {
|
|
LocalID: localID
|
|
};
|
|
msg.SurfaceInfo = [
|
|
{
|
|
UVCoord: uvCoordinate,
|
|
STCoord: stCoordinate,
|
|
FaceIndex: faceIndex,
|
|
Position: position,
|
|
Normal: normal,
|
|
Binormal: binormal
|
|
}
|
|
];
|
|
const seqID = this.circuit.sendMessage(msg, PacketFlags.Reliable);
|
|
await this.circuit.waitForAck(seqID, 10000);
|
|
}
|
|
|
|
async dragGrabbedObject(localID: number | UUID,
|
|
grabPosition: Vector3,
|
|
grabOffset: Vector3 = Vector3.getZero(),
|
|
uvCoordinate: Vector3 = Vector3.getZero(),
|
|
stCoordinate: Vector3 = Vector3.getZero(),
|
|
faceIndex: number = 0,
|
|
position: Vector3 = Vector3.getZero(),
|
|
normal: Vector3 = Vector3.getZero(),
|
|
binormal: Vector3 = Vector3.getZero())
|
|
{
|
|
// For some reason this message takes a UUID when the others take a LocalID - wtf?
|
|
if (!(localID instanceof UUID))
|
|
{
|
|
const obj: GameObject = this.currentRegion.objects.getObjectByLocalID(localID);
|
|
localID = obj.FullID;
|
|
}
|
|
const msg = new ObjectGrabUpdateMessage();
|
|
msg.AgentData = {
|
|
AgentID: this.agent.agentID,
|
|
SessionID: this.circuit.sessionID
|
|
};
|
|
msg.ObjectData = {
|
|
ObjectID: localID,
|
|
GrabOffsetInitial: grabOffset,
|
|
GrabPosition: grabPosition,
|
|
TimeSinceLast: 0
|
|
};
|
|
msg.SurfaceInfo = [
|
|
{
|
|
UVCoord: uvCoordinate,
|
|
STCoord: stCoordinate,
|
|
FaceIndex: faceIndex,
|
|
Position: position,
|
|
Normal: normal,
|
|
Binormal: binormal
|
|
}
|
|
];
|
|
const seqID = this.circuit.sendMessage(msg, PacketFlags.Reliable);
|
|
await this.circuit.waitForAck(seqID, 10000);
|
|
}
|
|
|
|
async touchObject(localID: number | UUID,
|
|
grabOffset: Vector3 = Vector3.getZero(),
|
|
uvCoordinate: Vector3 = Vector3.getZero(),
|
|
stCoordinate: Vector3 = Vector3.getZero(),
|
|
faceIndex: number = 0,
|
|
position: Vector3 = Vector3.getZero(),
|
|
normal: Vector3 = Vector3.getZero(),
|
|
binormal: Vector3 = Vector3.getZero())
|
|
{
|
|
if (localID instanceof UUID)
|
|
{
|
|
const obj: GameObject = this.currentRegion.objects.getObjectByUUID(localID);
|
|
localID = obj.ID;
|
|
}
|
|
await this.grabObject(localID, grabOffset, uvCoordinate, stCoordinate, faceIndex, position, normal, binormal);
|
|
await this.deGrabObject(localID, grabOffset, uvCoordinate, stCoordinate, faceIndex, position, normal, binormal);
|
|
}
|
|
}
|