But anyway, here is the example code:
def loopit(region):
# event_queue takes care of sequence numbers etc. This is it's state.
event_queue = UDPEventQueue(region)
#Alternative: udpeventqueue = IUDPEventQueue(region)
# send UseCircuitCode to sim (region object has everything)
# it also sends the CompleteAgentMovement
event_queue.init()
# now we need to send an AgentUpdate packet
# we do it the raw way here:
message = IAgentUpdateMessage(event_queue) # get the message
# agent_id, session_id will be put in automatically as well
# as sensible defaults for these properties so you don't have
# to give them all. Here they are as an example though,
# I am not sure if this needs to give the types already, we might
# give tuples etc. and convert it during the packing maybe.
# some flags might also be modelled higher level like
# message.flag_whatever = True
# but for this one would need to know more about them ;-)
message.body_rotation = Vector4(0,0,0,0)
message.head_rotation = Vector4(0,0,0,0)
message.state(0)
message.camera_center = Vector3(0,0,0)
message.camera_at_axis = Vector3(0,0,0)
message.camera_left_axis = Vector3(0,0,0)
message.camera_up_axis = Vector3(0,0,0)
message.far = F32(256)
message.control_flags = U32(0)
message.flags = U8(0)
# now we need to put this message into a packet:
packet = IPacket(message)
# this will automatically put in message type and sequence
# number which can be obtained via message -> event_queue
"""
The original code for this:
data_header = pack('>BLB', flags,currentsequence,0x00)
packed_data_message_ID = pack('>B',0x04)
packed_data_ID = uuid.UUID(result["agent_id"]).bytes + uuid.UUID
(result["session_id"]).bytes
packed_data_QuatRots = pack('<ffff', 0.0,0.0,0.0,0.0)+pack('<ffff',
0.0,0.0,0.0,0.0)
packed_data_State = pack('<B', 0x00)
packed_data_Camera = pack('<fff', 0.0,0.0,0.0)+pack('<fff',
0.0,0.0,0.0)+pack('<fff', 0.0,0.0,0.0)+pack('<fff', 0.0,0.0,0.0)
packed_data_Flags = pack('<fLB', 0.0,0x00,0x00)
"""
# it makes sense to actually send the packet.
# we can maybe do it like this as the event_queue is known:
packet.send()
# or we can do it like this:
event_queue.send(packet)
# without too much ZCA we can maybe also do the above like follows:
message = AgentUpdate(far=512) # fill in message details
packet = Packet(message) # create a packet out of this
event_queue.send(packet) # send it to the sim
# in this case the send method can only add sequence number etc.
# as it's the only instance which knows about it.
# We can implement it like this though:
def send(self, packet):
"""send a funky packet"""
packet.sequence_number = self.sequence_number
data = packet.serialize() # or ISerialization(packet).serialize()
self.sock.sendto(data, self.address)
# now we need to send a NameRequest, the original code is:
"""
packed_data = ""
fix_ID = int("0xffff0000",16)+ 235
data_header = pack('>BLB', 0x00,currentsequence,0x00)
for i in range(len(aUUID)):
packed_data = packed_data+uuid.UUID(aUUID[i]).bytes
packed_data = data_header + pack("L",fix_ID) + pack(">B",len(aUUID))
+ packed_data
sock.sendto(packed_data, (host, port))
"""
# We can write it as:
message = NameRequestMessage(uuids=[region.agent_id,])
# region.agent_id is what we have but it's not nice looking as it
# should be agent.id so this needs thinking to be clean. Maybe it
# even needs thinking inside the protocol ;-)
# In this case it's also not a direct mapping from message to message
# object as it needs to deal with variable blocks in this case.
packet = Packet(message)
event_queue.send(packet)
# now let's wait for packets
while 1:
# we might need a different method here as we might get
# events from the outside to send some packets.
# Then again there should be enough packets coming in to
# not endlessly sit in this read_packet() call.
packet = event_queue.read_packet()
message = packet.message
message_id = message.id
# get some handler for handling this lovely message
handlers = getUtilitiesFor(IMessageHandler, name=str(message_id))
for handler in handlers:
# we give it the message of course but also the event_queue
# so it maybe can send other packets out.
handler.handle(event_queue, message)
# now do some bookkeeping like acking messages etc.
# actually this could also be done in read_packet maybe
# we might need a way to get out of this loop.
"""
ORIGINAL CODE:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
#Sending packet UseCircuitCode <-- Inits the connection to the sim.
data = pack('>BLBL',0x00,0x01,00,0xffff0003) + pack
('<L',circuit_code) + uuid.UUID(result["session_id"]).bytes+uuid.UUID
(result["agent_id"]).bytes
sock.sendto(data, (host, port))
#ISending packet CompleteAgentMovement <-- establishes the agent's
presence
data = pack('>BLBL',0x00,0x02,00,0xffff00f9) + uuid.UUID(result
["agent_id"]).bytes + uuid.UUID(result["session_id"]).bytes + pack('<L',
circuit_code)
sock.sendto(data, (host, port))
sendAgentUpdate(sock, port, host, 3, result)
aUUID = [result["agent_id"]]
sendUUIDNameRequest(sock, port, host, 4,aUUID)
#
buf = 100
i = 0
trusted_count = 0
ackable = 0
trusted_and_ackable = 0
ack_need_list_changed = False
seqnum = 5
lastPingSent = 0
trusted = 0
while 1:
if ack_need_list_changed:
ack_need_list_changed = False
seqnum = seqnum + 1
sendPacketAck(sock, port, host,seqnum)
#sendAgentUpdate(sock, port, host, seqnum, result)
seqnum += 1
#sendacks()
i = i + 1
data,addr = sock.recvfrom(buf)
t = datetime.now()
t.strftime("%H:%M:%S")
"""
_______________________________________________
Click here to unsubscribe or manage your list subscription:
https://lists.secondlife.com/cgi-bin/mailman/listinfo/pyogp
