def __init__(self, agent = None, region = None, settings = None, message_handler = None, events_handler = None):
""" initialize the parcel manager """
super(ParcelManager, self).__init__(agent, settings)
self.region = region
self.message_handler = message_handler
# otherwise, let's just use our own
# unused atm
#if events_handler != None:
# self.events_handler = events_handler
#else:
# self.events_handler = AppEventsHandler()
self.helpers = Helpers()
# initialize the parcel storage container
self.parcels = []
# initialize the parcel overlay storage container
self.parcel_overlay = {}
# initialize map (x, y) with 0; filled in as parcel properties are received
self.parcel_map = [[0 for _ in range(64)] for _ in range(64)]
self.parcel_map_full = False
if self.settings.LOG_VERBOSE: logger.debug("Initializing the parcel manager in region %s." % (self.region.SimName))
def __init__(self, udp_client = None, settings = None, message_handler = None, message_template = None, message_xml = None):
#holds the details of the message, or how the messages should be sent,
#built, and read
self.packets_in = 0
self.packets_out = 0
self.circuit_manager = CircuitManager()
self.data_unpacker = DataUnpacker()
#the ID of the packet we most recently received
self.receive_packet_id = -1
if udp_client == None:
self.udp_client = NetUDPClient()
else:
self.udp_client = udp_client
self.udp_client.start_udp_connection()
# allow the settings to be passed in
# otherwise, grab the defaults
if settings != None:
self.settings = settings
else:
self.settings = Settings()
# allow the passing in of message_template.xml as a file handle
if not message_template:
self.message_template = None
else:
if isinstance(message_template, file):
self.message_template = message_template
else:
log.warning("%s parameter is expected to be a filehandle, it is a %s. \
Using the embedded message_template.msg" % (message_template, type(message_template)))
self.message_template = None
if not message_xml:
self.message_xml = MessageDotXML()
else:
self.message_xml = message_xml
self.helpers = Helpers()
# allow the packet_handler to be passed in
# otherwise, grab the defaults
if message_handler != None:
self.message_handler = message_handler
elif self.settings.HANDLE_PACKETS:
from pyogp.lib.base.message.message_handler import MessageHandler
self.message_handler = MessageHandler()
# set up our parsers
self.udp_deserializer = UDPMessageDeserializer(self.message_handler,
self.settings,
message_template = self.message_template)
self.udp_serializer = UDPMessageSerializer(message_template = self.message_template)
def __init__(self, agent, settings=None):
"""
initialize the appearance manager
"""
super(AppearanceManager, self).__init__(agent, settings)
self.AgentSetSerialNum = 1
self.AgentCachedSerialNum = 1
self.wearables = {} #indexed by WearableType
for i in range(TextureIndex.TEX_COUNT):
self.wearables[i] = Wearable(i)
self.helpers = Helpers()
self.bakedTextures = {} #indexed by TextureIndex
for i in range(BakedIndex.BAKED_COUNT):
self.bakedTextures[i] = BakedTexture(i)
self.visualParams = VisualParams().params
self.visualParams[32].value = 1.0
self.TextureEntry = ""
self.requests = []
def __init__(self, settings = None, firstname = '', lastname = '', password = '', agent_id = None, events_handler = None, handle_signals=True):
""" initialize this agent """
# allow the settings to be passed in
# otherwise, grab the defaults
if settings != None:
self.settings = settings
else:
from pyogp.lib.client.settings import Settings
self.settings = Settings()
# allow the eventhandler to be passed in
# so that applications running multiple avatars
# may use the same eventhandler
# otherwise, let's just use our own
if events_handler != None:
self.events_handler = events_handler
else:
self.events_handler = AppEventsHandler()
# signal handler to capture erm signals
if handle_signals:
self.signal_handler = signal.signal(signal.SIGINT, self.sigint_handler)
# storage containers for agent attributes
# we overwrite with what the grid tells us, rather than what
# is passed in and stored in Login()
self.firstname = firstname
self.lastname = lastname
self.password = password
self.agent_id = None
self.session_id = None
self.local_id = None
self.secure_session_id = None
self.name = self.Name()
self.active_group_powers = None
self.active_group_name = None
self.active_group_title = None
self.active_group_id = None
self.health = None
self._login_params = None
self.circuit_code = None
# other storage containers
self.inventory_host = None
self.agent_access = None
self.udp_blacklist = None
self.home = None
self.inventory = None
self.start_location = None
self.group_manager = GroupManager(self, self.settings)
self.asset_manager = AssetManager(self, self.settings)
self.map_service = MapService(self, self.settings)
# additional attributes
self.login_response = None
self.connected = False
self.grid_type = None
self.running = True
self.helpers = Helpers()
# data we store as it comes in from the grid
self.Position = Vector3() # this will get updated later, but seed it with 000
self.LookAt = Vector3()
self.ActiveGroupID = UUID()
# populated via ObjectUpdates
self.FootCollisionPlane = Quaternion()
self.Velocity = Vector3()
self.Acceleration = Vector3()
self.Rotation = Vector3()
self.AngularVelocity = Vector3()
# movement
self.state = AgentState.Null # typing, editing
self.control_flags = 0
self.agent_update_flags = AgentUpdateFlags.Null
# should we include these here?
self.agentdomain = None # the agent domain the agent is connected to if an OGP context
self.child_regions = [] # all neighboring regions
self._pending_child_regions = [] # neighbor regions an agent may connect to
self.region = None # the host simulation for the agent
# init AppearanceManager()
self.appearance = AppearanceManager(self, self.settings)
# Cache of agent_id->(first_name, last_name); per agent to prevent info leaks
self.agent_id_map = {}
if self.settings.LOG_VERBOSE:
logger.debug('Initializing agent: %s' % (self))
def request_asset(self,
assetID,
assetType,
isPriority,
callback=None,
itemID=None):
"""
Sends a TransferRequest to the sim for asset assetID with type assetType,
will call callback with the assetID and True with the asset received or False
if request failed. On successful request the asset is store in
self.assets
TODO add a timeout
"""
transferID = UUID() #associate the assetID with the transferID
transferID.random()
transferInfoHandler = self.agent.region.message_handler.register(
'TransferInfo')
transferPacketHandler = self.agent.region.message_handler.register(
'TransferPacket')
def onTransferPacket(packet):
"""
TransferPacket of a successful TransferRequest
"""
# fill in data for Asset in the requests queue and pop it off and story in assets dict
if str(transferID) == str(packet['TransferData'][0]['TransferID']):
# insert packet
self.assets[str(assetID)].store_packet(
packet['TransferData'][0]['Packet'],
packet['TransferData'][0]['Data'],
packet['TransferData'][0]['Status'])
if self.assets[str(assetID)].is_downloaded():
self.assets[str(assetID)].assemble_data()
if callback != None:
callback(assetID, True)
transferPacketHandler.unsubscribe(onTransferPacket)
else:
pass
# wait for more packets
def onTransferInfo(packet):
"""
Status of TransferRequest
Account for size and multiple packets
"""
if not self.assets.has_key(str(assetID)):
self.assets[str(assetID)] = Asset(assetID, assetType)
if str(transferID) == str(packet['TransferInfo'][0]['TransferID']):
status = packet['TransferInfo'][0]["Status"]
if status != TransferStatus.OK:
logger.warning("Request for asset %s failed with status %s" \
% (assetID, status))
if callback != None:
callback(assetID, False)
transferPacketHandler.unsubscribe(onTransferPacket)
else:
self.assets[str(
assetID)].size = packet['TransferInfo'][0]['Size']
transferInfoHandler.unsubscribe(onTransferInfo)
transferInfoHandler.subscribe(onTransferInfo)
transferPacketHandler.subscribe(onTransferPacket)
if isPriority:
priority = 1.0
else:
priority = 0.0
params = ''
if itemID != None:
params += self.agent.agent_id.get_bytes() + \
self.agent.session_id.get_bytes() + \
self.agent.agent_id.get_bytes() + \
UUID().get_bytes() + \
itemID.get_bytes()
params += assetID.get_bytes() + \
Helpers().int_to_bytes(assetType)
self.send_TransferRequest(transferID, TransferChannelType.Asset,
TransferSourceType.Asset, priority, params)
