def sendRezObject(agent, inventory_item, RayStart, RayEnd, FromTaskID=UUID(), BypassRaycast=1, RayTargetID=UUID(), RayEndIsIntersection=False, RezSelected=False, RemoveItem=True, ItemFlags=0, GroupMask=0, EveryoneMask=0, NextOwnerMask=0): """ sends a RezObject packet to a region """ packet = Message( 'RezObject', Block('AgentData', AgentID=agent.agent_id, SessionID=agent.session_id, GroupID=agent.ActiveGroupID), Block('RezData', FromTaskID=UUID(str(FromTaskID)), BypassRaycast=BypassRaycast, RayStart=RayStart, RayEnd=RayEnd, RayTargetID=UUID(str(RayTargetID)), RayEndIsIntersection=RayEndIsIntersection, RezSelected=RezSelected, RemoveItem=RemoveItem, ItemFlags=ItemFlags, GroupMask=GroupMask, EveryoneMask=EveryoneMask, NextOwnerMask=NextOwnerMask), Block('InventoryData', ItemID=inventory_item.ItemID, FolderID=inventory_item.FolderID, CreatorID=inventory_item.CreatorID, OwnerID=inventory_item.OwnerID, GroupID=inventory_item.GroupID, BaseMask=inventory_item.BaseMask, OwnerMask=inventory_item.OwnerMask, GroupMask=inventory_item.GroupMask, EveryoneMask=inventory_item.EveryoneMask, GroupOwned=inventory_item.GroupOwned, TransactionID=UUID(), Type=inventory_item.Type, InvType=inventory_item.InvType, Flags=inventory_item.Flags, SaleType=inventory_item.SaleType, SalePrice=inventory_item.SalePrice, Name=inventory_item.Name, Description=inventory_item.Description, CreationDate=inventory_item.CreationDate, CRC=inventory_item.CRC, NextOwnerMask=inventory_item.NextOwnerMask)) agent.region.enqueue_message(packet)
def processGetScriptRunning(self, obj_id, item_id): print("GetScriptRunning", obj_id, item_id) agent = self.manager.client packet = Message( 'GetScriptRunning', Block('Script', ObjectID=UUID(str(obj_id)), ItemID=UUID(str(item_id)))) agent.region.enqueue_message(packet)
def onInventoryDescendents(self, packet): if packet['AgentData'][0]['Descendents'] > 0: _agent_id = packet['AgentData'][0]['AgentID'] _folder_id = packet['AgentData'][0]['FolderID'] _owner_id = packet['AgentData'][0]['OwnerID'] _version = packet['AgentData'][0]['Version'] _descendents = packet['AgentData'][0]['Descendents'] # _descendents is not dealt with in any way here if str(packet['ItemData'][0]['ItemID']) != str(UUID()): for ItemData_block in packet['ItemData']: _ItemID = ItemData_block['ItemID'] _FolderID = ItemData_block['FolderID'] _CreatorID = ItemData_block['CreatorID'] _OwnerID = ItemData_block['OwnerID'] _GroupID = ItemData_block['GroupID'] _BaseMask = ItemData_block['BaseMask'] _OwnerMask = ItemData_block['OwnerMask'] _GroupMask = ItemData_block['GroupMask'] _EveryoneMask = ItemData_block['EveryoneMask'] _NextOwnerMask = ItemData_block['NextOwnerMask'] _GroupOwned = ItemData_block['GroupOwned'] _AssetID = ItemData_block['AssetID'] _Type = ItemData_block['Type'] _InvType = ItemData_block['InvType'] _Flags = ItemData_block['Flags'] _SaleType = ItemData_block['SaleType'] _SalePrice = ItemData_block['SalePrice'] _Name = ItemData_block['Name'] _Description = ItemData_block['Description'] _CreationDate = ItemData_block['CreationDate'] _CRC = ItemData_block['CRC'] inventory_item = InventoryItem(_ItemID, _FolderID, _CreatorID, _OwnerID, _GroupID, _BaseMask, _OwnerMask, _GroupMask, _EveryoneMask, _NextOwnerMask, _GroupOwned, _AssetID, _Type, _InvType, _Flags, _SaleType, _SalePrice, _Name, _Description, _CreationDate, _CRC) self._store_inventory_item(inventory_item) if str(packet['FolderData'][0]['FolderID']) != str(UUID()): for FolderData_block in packet['FolderData']: _FolderID = FolderData_block['FolderID'] _ParentID = FolderData_block['ParentID'] _Type = FolderData_block['Type'] _Name = FolderData_block['Name'] folder = InventoryFolder( _Name, _FolderID, _ParentID, None, _Type, _agent_id) self._store_inventory_folder(folder)
def processScriptReset(self, obj_id, item_id): agent = self.manager.client packet = Message( 'ScriptReset', Block('AgentData', AgentID=agent.agent_id, SessionID=agent.session_id), Block('Script', ObjectID=UUID(str(obj_id)), ItemID=UUID(str(item_id)))) agent.region.enqueue_message(packet)
def processCreateInventoryItem(self, trID, asset_type, inv_type, name, desc): wearable_type = 0 agent = self.manager.client next_owner_permission = 0 print("processCreateInventoryItem", trID, asset_type) self.inventory.send_CreateInventoryItem(agent.agent_id, agent.session_id, 0, UUID(), UUID(trID), next_owner_permission, asset_type, inv_type, wearable_type, name, desc)
def processSetScriptRunning(self, obj_id, item_id, running): print("SetScriptRunning", obj_id, item_id, running) agent = self.manager.client packet = Message( 'SetScriptRunning', Block('AgentData', AgentID=agent.agent_id, SessionID=agent.session_id), Block('Script', ObjectID=UUID(str(obj_id)), ItemID=UUID(str(item_id)), Running=int(running))) agent.region.enqueue_message(packet)
def request_agent_wearables(self): """ Asks the simulator what the avatar is wearing #TODO create a one--shot callback """ if self.agent.agent_id == None or self.agent.session_id == None or \ str(self.agent.agent_id) == str(UUID()) or \ str(self.agent.session_id) == str(UUID()): logger.warning( "Agent has either no agent_id or session_id, message not sent") return self.send_AgentWearablesRequest(self.agent.agent_id, self.agent.session_id)
def __init__(self, Name = None, FolderID = None, ParentID = None, Version = None, Type = None, AgentID = UUID(), Descendents = 0): """ initialize the inventory folder """ self.type = 'InventoryFolder' self.Name = Name self.FolderID = UUID(str(FolderID)) self.ParentID = UUID(str(ParentID)) self.Version = Version self.Type = Type self.Descendents = Descendents self.AgentID = UUID(str(AgentID)) self.inventory = []
def store_agent(self, agent): """ adds an agent to the store """ if str(type(agent)) != '<class \'pyogp.lib.client.agent.Agent\'>': logger.warning("The AgentManager stores only Agent instances to initialize. Stopping.") return False # check if the agent is on the store if self._is_stored(agent) == False: if agent.agent_id == None: key = UUID().random() else: key = agent.agent_id self.agents[key] = agent logger.info("Stored agent %s with a key of %s" % (agent.name, key)) else: if agent.firstname != None and agent.lastname != None: uniq = ' named ' + agent.Name() logger.warning("The AgentManager is already storing an agent%s. Stopping." % (uniq))
def parse_data(self): if not self.data: return tokens = self.data.split() i = iter(tokens) while True: try: token = i.next() if token.lower() == 'version': self.Version = int(i.next()) if token.lower() == 'type': self.Type = int(i.next()) if token.lower() == 'parameters': count = int(i.next()) for num in range(count): paramID = int(i.next()) paramVal = i.next() #TODO Verify this is correct behavior this fix may be a hack if paramVal == '.': self.params[paramID] = 0.0 else: self.params[paramID] = float(paramVal) if token.lower() == 'textures': count = int(i.next()) for num in range(count): textureID = int(i.next()) self.textures[textureID] = UUID(i.next()) except StopIteration: break
def processCreate(self, obj_name, obj_uuid_str, mesh_name, mesh_uuid_str, pos, rot, scale, b64data, materials): # create asset obj_uuid = UUID(obj_uuid_str) data = base64.urlsafe_b64decode(b64data.encode('ascii')) self._next_create = (self._next_create + 1) % (256*256) obj_idx = self._next_create def finishupload(asset_id, transaction_id): # asset uploaded, we have its uuid and can proceed now tok = UUID(str(uuid.uuid4())) def finish_creating(real_uuid): # object finished creating and here we get its real uuid and can # confirm creation to the client sending the new uuids. del self._creating_cb[obj_idx] args = {"RexMeshUUID": str(asset_id), "RexIsVisible": True, "materials": materials} #self.processPos(obj_uuid_str, pos, rot) self.rexdata.sendRexPrimData(real_uuid, args) self.out_queue.put(["meshcreated", obj_uuid_str, mesh_uuid_str, str(real_uuid), str(asset_id)]) self._creating_cb[obj_idx] = finish_creating self.sendCreateObject(obj_uuid, pos, rot, scale, obj_idx) # send the asset data and wait for ack from the uploader assetID = self.manager.uploader.uploadAsset(AssetType.OgreMesh, data, finishupload)
def send_UUIDNameRequest(self, agent_ids, callback): """ sends a UUIDNameRequest message to the host simulator """ handler = self.region.message_handler.register('UUIDNameReply') def onUUIDNameReply(packet): """ handles the UUIDNameReply message from a simulator """ logger.info('UUIDNameReplyPacket received') cbdata = [] for block in packet['UUIDNameBlock']: agent_id = str(block['ID']) first_name = block['FirstName'] last_name = block['LastName'] self.agent_id_map[agent_id] = (first_name, last_name) cbdata.append((agent_id, first_name, last_name)) # Fire the callback only when all names are received missing = [ agent_id for agent_id in agent_ids if agent_id not in self.agent_id_map ] if not missing: handler.unsubscribe(onUUIDNameReply) callback(cbdata) else: logger.info('Still waiting on %d names in send_UUIDNameRequest', len(missing)) handler.subscribe(onUUIDNameReply) logger.info('sending UUIDNameRequest') packet = Message('UUIDNameRequest', [Block('UUIDNameBlock', ID = UUID(agent_id)) for agent_id in agent_ids]) self.region.enqueue_message(packet)
def request_join_group_chat(self): """ sends an ImprovedInstantMessage packet with the atributes necessary to join a group chat """ logger.info("Requesting to join group chat session for \'%s\'" % (self.GroupName)) _AgentID = self.agent.agent_id _SessionID = self.agent.session_id _FromGroup = False _ToAgentID = self.GroupID _ParentEstateID = 0 _RegionID = UUID() _Position = Vector3() _Offline = 0 _Dialog = ImprovedIMDialogue.SessionGroupStart _ID = self.GroupID _Timestamp = 0 _FromAgentName = self.agent.Name() _Message = 'Message' '' _BinaryBucket = '' self.agent.send_ImprovedInstantMessage(_AgentID, _SessionID, _FromGroup, _ToAgentID, _ParentEstateID, _RegionID, _Position, _Offline, _Dialog, _ID, _Timestamp, _FromAgentName, _Message, _BinaryBucket)
def fetch_agent_properties(client, agent_id, callback=None): # Send AvatarPropertiesRequest # Get back AvatarPropertiesReply def onAgentPropertiesReply(packet): if repr(packet['AgentData'][0]['AvatarID']) == agent_id: block = packet['PropertiesData'][0] for prop in [ 'ImageID', 'FLImageID', 'PartnerID', 'AboutText', 'FLAboutText', 'BornOn', 'ProfileURL', 'CharterMember', 'Flags' ]: print "%s: %s" % (prop, block[prop]) if callback: callback(packet) client.region.message_handler.register('AvatarPropertiesReply').subscribe( onAgentPropertiesReply) packet = Message( 'AvatarPropertiesRequest', Block('AgentData', AgentID=client.agent_id, SessionID=client.session_id, AvatarID=UUID(agent_id))) client.region.enqueue_message(packet)
def sendLocalTeleport(self, agent, pos): client = self.manager.client if not agent.FullID == client.agent_id: print("Trying to move an agent for other user") t_id = uuid.uuid4() invoice_id = UUID() client.teleport(region_handle=client.region.RegionHandle, position=Vector3(X=pos[0], Y=pos[1], Z=pos[2]))
def create_default_wearables(self): create = [True, True, True, True, True, True, True, True, False, False, \ True, True, False] for i in range(WearablesIndex.WT_COUNT): if create[i]: asset_id == UUID() asset_id.random() self.wearables[i] = Wearable(i, AssetID=asset_id)
def processRezScript(self, obj_uuid_str, item_id): agent = self.manager.client obj = agent.region.objects.get_object_from_store(FullID=obj_uuid_str) item = self.findItem(item_id) if obj and item: agent.region.objects.send_RezScript(agent, obj, UUID(item_id), Name=item.Name)
def processClone(self, obj_name, obj_uuid_str, mesh_name, mesh_uuid_str, pos, rot, scale, materials): # create asset obj_uuid = UUID(obj_uuid_str) self._next_create = (self._next_create + 1) % (256*256) obj_idx = self._next_create tok = UUID(str(uuid.uuid4())) def finish_creating(real_uuid, transaction_id): del self._creating_cb[obj_idx] args = {"RexMeshUUID": mesh_uuid_str, "materials": materials, "RexIsVisible": True} self.out_queue.put(["meshcreated", obj_uuid_str, mesh_uuid_str, str(real_uuid), mesh_uuid_str]) self.rexdata.sendRexPrimData(real_uuid, args) self._creating_cb[obj_idx] = finish_creating self.sendCreateObject(obj_uuid, pos, rot, scale, obj_idx)
def processScriptSensorRequest(self, obj_id, item_id, *args): agent = self.manager.client # XXX missing parameter setup packet = Message( 'ScriptSensorRequest', Block('Requester', SourceID=UUID(source_id), RequestID=UUID(request_id), SearchID=UUID(search_id), SearchPos=Vector3(search_pos), SearchDir=Quaternion(search_dir), SearchName=search_name, Type=_type, Range=_range, Arc=arc, RegionHandle=region_handle, SearchRegions=search_regions)) agent.region.enqueue_message(packet)
def instant_message(self, ToAgentID = None, _Message = None, _ID = None): """ sends an instant message to another avatar, wrapping Agent().send_ImprovedInstantMessage() with some handy defaults """ if ToAgentID != None and _Message != None: if _ID == None: _ID = self.agent_id _AgentID = self.agent_id _SessionID = self.session_id _FromGroup = False _ToAgentID = UUID(str(ToAgentID)) _ParentEstateID = 0 _RegionID = UUID() _Position = self.Position _Offline = 0 _Dialog = ImprovedIMDialogue.FromAgent _ID = _ID _Timestamp = 0 _FromAgentName = self.firstname + ' ' + self.lastname _Message = _Message _BinaryBucket = '' self.send_ImprovedInstantMessage(_AgentID, _SessionID, _FromGroup, _ToAgentID, _ParentEstateID, _RegionID, _Position, _Offline, _Dialog, _ID, _Timestamp, _FromAgentName, _Message, _BinaryBucket) else: logger.info("Please specify an agentid and message to send in agent.instant_message")
def object_created(object_info): prim = object_info.payload['object'] matches = client.inventory.search_inventory( client.inventory.folders, name="Objects") folder = matches.pop() transaction_id = UUID() transaction_id.random() prim.derez(client, DeRezDestination.TakeIntoAgentInventory, folder.FolderID, transaction_id, client.active_group_id) s.signal()
def processRemoveInventoryItem(self, item_id): logger = self.logger logger.debug('processRemoveIntenvoryItem') self.removeInventoryItem(item_id) client = self.manager.client self.inventory.send_RemoveInventoryItem(client.agent_id, client.session_id, UUID(str(item_id)))
def get_hash(self, wearables): """ Creates a hash using the assetIDs for each wearable in a baked layer """ wearable_map = WearableMap().map hash = UUID() for wearable_index in wearable_map[self.bakedIndex]: hash ^= wearables[wearable_index].AssetID if str(hash) != '00000000-0000-0000-0000-000000000000': hash ^= self.secret_hash return hash
def sendUpdateInventoryItem(self, agent, transaction_id, inventory_items=[]): """ sends an UpdateInventoryItem packet to a region this function expects an InventoryItem instance already with updated data """ packet = Message( 'UpdateInventoryItem', Block('AgentData', AgentID=agent.agent_id, SessionID=agent.session_id, TransactionID=UUID()), *[ Block('InventoryData', ItemID=item.ItemID, FolderID=item.FolderID, CallbackID=random.randint(0, pow(2, 32) - 1), CreatorID=item.CreatorID, OwnerID=item.OwnerID, GroupID=item.GroupID, BaseMask=item.BaseMask, OwnerMask=item.OwnerMask, GroupMask=item.GroupMask, EveryoneMask=item.EveryoneMask, NextOwnerMask=item.NextOwnerMask, GroupOwned=item.GroupOwned, TransactionID=UUID(transaction_id), Type=item.Type, InvType=item.InvType, Flags=item.Flags, SaleType=item.SaleType, SalePrice=item.SalePrice, Name=item.Name, Description=item.Description, CreationDate=item.CreationDate, CRC=item.CRC) for item in inventory_items ]) agent.region.enqueue_message(packet)
def test_onObjectUpdate_selected(self): self.object_store.agent = Agent() fake_uuid = UUID() fake_uuid.random() packet = Message( 'ObjectUpdate', Block('RegionData', RegionHandle=0, TimeDilation=0), Block('ObjectData', ID=1, State=1, FullID=fake_uuid, CRC=0, PCode=0, Material=0, ClickAction=0, Scale=Vector3(X=0.0, Y=0.0, Z=0.0), ObjectData='', ParentID=fake_uuid, UpdateFlags=0, ProfileCurve=0, PathBegin=0.0, PathEnd=0.0, PathScaleX=0.0, PathScaleY=0.0, PathShearX=0.0, PathShearY=0.0, PathTwist=-1, PathTwistBegin=-1, PathRadiusOffset=-1, PathTaperX=-1, PathTaperY=-1, PathRevolutions=0, PathSkew=-1, ProfileBegin=0, ProfileEnd=0, ProfileHollow=0, TextureEntry='', TextureAnim='', NameValue='Test', Data='', Text='', TextColor=0x0, MedialURL='')) def callback(payload): self.data.append("foo") object_handler = self.object_store.agent.events_handler.register( "ObjectSelected") object_handler.subscribe(callback) self.object_store.region.message_handler.handle(packet) self.assertTrue(self.data.pop, "foo")
def processPos(self, objId, pos, rot=None): client = self.client obj = client.region.objects.get_object_from_store(FullID=objId) if not obj: obj = client.region.objects.get_avatar_from_store(FullID=UUID(objId)) if obj: self.manager.misc.sendLocalTeleport(obj, pos) return if obj: pos = pos rot = rot self.sendPositionUpdate(obj, pos, rot)
def create_new_item(self, folder, name, desc, asset_type, inv_type, wearable_type, next_owner_permission, callback=None): """ Creates a new item in folder. """ transaction_id = UUID() transaction_id.random() updateCreateInventoryHandler = self.agent.region.message_handler.register('UpdateCreateInventoryItem') def onUpdateCreateInventoryItem(packet): if str(transaction_id) != str(packet['AgentData'][0]['TransactionID']): inv_data = packet['InventoryData'][0] item = InventoryItem(inv_data['ItemID'], inv_data['FolderID'], inv_data['CreatorID'], inv_data['OwnerID'], inv_data['GroupID'], inv_data['BaseMask'], inv_data['OwnerMask'], inv_data['GroupMask'], inv_data['EveryoneMask'], inv_data['NextOwnerMask'], inv_data['GroupOwned'], inv_data['AssetID'], inv_data['Type'], inv_data['InvType'], inv_data['Flags'], inv_data['SaleType'], inv_data['SalePrice'], inv_data['Name'], inv_data['Description'], inv_data['CreationDate'], inv_data['CRC']) self._store_inventory_item(item) updateCreateInventoryHandler.unsubscribe(onUpdateCreateInventoryItem) if callback != None: callback(item) updateCreateInventoryHandler.subscribe(onUpdateCreateInventoryItem) self.send_CreateInventoryItem(self.agent.agent_id, self.agent.session_id, 0, folder.FolderID, transaction_id, next_owner_permission, asset_type, inv_type, wearable_type, name, desc)
def sendParcelDwellRequest(self, agent_id, session_id, LocalID): """ send a ParcelDwellRequest packet """ packet = Message('ParcelDwellRequest', Block('AgentData', AgentID = agent_id, SessionID = session_id), Block('Data', LocalID = LocalID, ParcelID = UUID())) self.region.enqueue_message(packet, True)
def __init__(self, ItemID = None, FolderID = None, CreatorID = None, OwnerID = None, GroupID = None, BaseMask = None, OwnerMask = None, GroupMask = None, EveryoneMask = None, NextOwnerMask = 0, GroupOwned = None, AssetID = None, Type = None, InvType = None, Flags = None, SaleType = None, SalePrice = None, Name = None, Description = None, CreationDate = None, CRC = None, LastOwnerID = UUID()): """ initialize the inventory item """ self.type = 'InventoryItem' self.ItemID = UUID(str(ItemID)) # LLUUID self.FolderID = UUID(str(FolderID)) # LLUUID self.CreatorID = UUID(str(CreatorID)) # LLUUID self.OwnerID = UUID(str(OwnerID)) # LLUUID self.GroupID = UUID(str(GroupID)) # LLUUID self.BaseMask = BaseMask # U32 self.OwnerMask = OwnerMask # U32 self.GroupMask = GroupMask # U32 self.EveryoneMask = EveryoneMask # U32 self.NextOwnerMask = NextOwnerMask self.GroupOwned = GroupOwned # Bool self.AssetID = UUID(str(AssetID)) # LLUUID self.Type = Type # S8 self.InvType = InvType # S8 self.Flags = Flags # U32 self.SaleType = SaleType # U8 self.SalePrice = SalePrice # S32 self.Name = Name # Variable 1 self.Description = Description # Variable 1 self.CreationDate = CreationDate # S32 self.CRC = CRC # U32 self.LastOwnerID = UUID(str(LastOwnerID))
def create_group(self, AgentID=None, SessionID=None, Name=None, Charter='', ShowInList=True, InsigniaID=UUID(), MembershipFee=0, OpenEnrollment=False, AllowPublish=False, MaturePublish=False): """ sends a message to the agent's current region requesting to create a group enables a callback (which should be unsubscribed from once we get a response) """ if Name != None: logger.info( "Sending a request to create group with a name of \'%s\'" % (Name)) if AgentID == None: AgentID = self.agent.agent_id if SessionID == None: SessionID = self.agent.session_id packet = Message( 'CreateGroupRequest', Block('AgentData', AgentID=AgentID, SessionID=SessionID), Block('GroupData', Name=Name, Charter=Charter, ShowInList=ShowInList, InsigniaID=InsigniaID, MembershipFee=MembershipFee, OpenEnrollment=OpenEnrollment, AllowPublish=AllowPublish, MaturePublish=MaturePublish)) self.agent.region.enqueue_message(packet, True) # enable the callback to watch for the CreateGroupReply packet self.onCreateGroupReply_received = self.agent.region.message_handler.register( 'CreateGroupReply') self.onCreateGroupReply_received.subscribe(self.onCreateGroupReply) else: raise DataParsingError( 'Failed to create a group, please specify a name')