Exemplo n.º 1
0
        /// <summary>Process an incoming packet and raise the appropriate events</summary>
        /// <param name="sender">The sender</param>
        /// <param name="e">The EventArgs object containing the packet data</param>
        protected void OfflineNotificationHandler(object sender, PacketReceivedEventArgs e)
        {
            Packet packet = e.Packet;

            if (packet.Type == PacketType.OfflineNotification)
            {
                OfflineNotificationPacket notification = (OfflineNotificationPacket)packet;

                foreach (OfflineNotificationPacket.AgentBlockBlock block in notification.AgentBlock)
                {
                    FriendInfo friend = new FriendInfo(block.AgentID, FriendRights.CanSeeOnline, FriendRights.CanSeeOnline);

                    lock (FriendList.Dictionary)
                    {
                        if (!FriendList.Dictionary.ContainsKey(block.AgentID))
                        {
                            FriendList.Dictionary[block.AgentID] = friend;
                        }

                        friend = FriendList.Dictionary[block.AgentID];
                    }

                    friend.IsOnline = false;

                    if (m_FriendOffline != null)
                    {
                        OnFriendOffline(new FriendInfoEventArgs(friend));
                    }
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Handle notifications sent when a friends has gone offline.
        /// </summary>
        /// <param name="packet"></param>
        /// <param name="simulator"></param>
        private void OfflineNotificationHandler(Packet packet, Simulator simulator)
        {
            if (packet.Type == PacketType.OfflineNotification)
            {
                OfflineNotificationPacket notification = ((OfflineNotificationPacket)packet);

                foreach (OfflineNotificationPacket.AgentBlockBlock block in notification.AgentBlock)
                {
                    FriendInfo friend;

                    lock (FriendList)
                    {
                        if (!FriendList.ContainsKey(block.AgentID))
                        {
                            FriendList.Add(block.AgentID, new FriendInfo(block.AgentID, FriendRights.CanSeeOnline, FriendRights.CanSeeOnline));
                        }

                        friend          = FriendList[block.AgentID];
                        friend.IsOnline = false;
                    }

                    if (OnFriendOffline != null)
                    {
                        try { OnFriendOffline(friend); }
                        catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
                    }
                }
            }
        }
Exemplo n.º 3
0
        public void DisconnectClient(Agent agent)
        {
            // Remove the avatar from the scene
            SimulationObject obj;

            if (Scene.TryGetObject(agent.AgentID, out obj))
            {
                Scene.ObjectRemove(this, obj);
            }
            else
            {
                Logger.Log("Disconnecting an agent that is not in the scene", Helpers.LogLevel.Warning);
            }

            // Remove the UDP client
            UDP.RemoveClient(agent);

            // HACK: Notify everyone when someone disconnects
            OfflineNotificationPacket offline = new OfflineNotificationPacket();

            offline.AgentBlock            = new OfflineNotificationPacket.AgentBlockBlock[1];
            offline.AgentBlock[0]         = new OfflineNotificationPacket.AgentBlockBlock();
            offline.AgentBlock[0].AgentID = agent.AgentID;
            UDP.BroadcastPacket(offline, PacketCategory.State);
        }
Exemplo n.º 4
0
        public void DisconnectClient(Agent agent)
        {
            // Remove the avatar from the scene
            SimulationObject obj;
            if (Scene.TryGetObject(agent.AgentID, out obj))
                Scene.ObjectRemove(this, obj);
            else
                Logger.Log("Disconnecting an agent that is not in the scene", Helpers.LogLevel.Warning);

            // Remove the UDP client
            UDP.RemoveClient(agent);

            // HACK: Notify everyone when someone disconnects
            OfflineNotificationPacket offline = new OfflineNotificationPacket();
            offline.AgentBlock = new OfflineNotificationPacket.AgentBlockBlock[1];
            offline.AgentBlock[0] = new OfflineNotificationPacket.AgentBlockBlock();
            offline.AgentBlock[0].AgentID = agent.AgentID;
            UDP.BroadcastPacket(offline, PacketCategory.State);
        }
Exemplo n.º 5
0
        void ImprovedInstantMessageHandler(Packet packet, Agent agent)
        {
            ImprovedInstantMessagePacket im     = (ImprovedInstantMessagePacket)packet;
            InstantMessageDialog         dialog = (InstantMessageDialog)im.MessageBlock.Dialog;

            if (dialog == InstantMessageDialog.FriendshipOffered || dialog == InstantMessageDialog.FriendshipAccepted || dialog == InstantMessageDialog.FriendshipDeclined)
            {
                lock (server.Agents)
                {
                    foreach (Agent recipient in server.Agents.Values)
                    {
                        if (recipient.AgentID == im.MessageBlock.ToAgentID)
                        {
                            ImprovedInstantMessagePacket sendIM = new ImprovedInstantMessagePacket();
                            sendIM.MessageBlock.RegionID       = UUID.Random(); //FIXME
                            sendIM.MessageBlock.ParentEstateID = 1;
                            sendIM.MessageBlock.FromGroup      = false;
                            sendIM.MessageBlock.FromAgentName  = Utils.StringToBytes(agent.Avatar.Name);
                            sendIM.MessageBlock.ToAgentID      = im.MessageBlock.ToAgentID;
                            sendIM.MessageBlock.Dialog         = im.MessageBlock.Dialog;
                            sendIM.MessageBlock.Offline        = (byte)InstantMessageOnline.Online;
                            sendIM.MessageBlock.ID             = agent.AgentID;
                            sendIM.MessageBlock.Message        = im.MessageBlock.Message;
                            sendIM.MessageBlock.BinaryBucket   = new byte[0];
                            sendIM.MessageBlock.Timestamp      = 0;
                            sendIM.MessageBlock.Position       = agent.Avatar.Position;

                            sendIM.AgentData.AgentID = agent.AgentID;

                            server.UDP.SendPacket(recipient.AgentID, sendIM, PacketCategory.Transaction);

                            if (dialog == InstantMessageDialog.FriendshipAccepted)
                            {
                                bool receiverOnline = server.Agents.ContainsKey(agent.AgentID);
                                bool senderOnline   = server.Agents.ContainsKey(recipient.AgentID);

                                if (receiverOnline)
                                {
                                    if (senderOnline)
                                    {
                                        OnlineNotificationPacket notify = new OnlineNotificationPacket();
                                        notify.AgentBlock            = new OnlineNotificationPacket.AgentBlockBlock[0];
                                        notify.AgentBlock[0]         = new OnlineNotificationPacket.AgentBlockBlock();
                                        notify.AgentBlock[0].AgentID = agent.AgentID;
                                        server.UDP.SendPacket(recipient.AgentID, notify, PacketCategory.State);
                                    }
                                    else
                                    {
                                        OfflineNotificationPacket notify = new OfflineNotificationPacket();
                                        notify.AgentBlock            = new OfflineNotificationPacket.AgentBlockBlock[0];
                                        notify.AgentBlock[0]         = new OfflineNotificationPacket.AgentBlockBlock();
                                        notify.AgentBlock[0].AgentID = agent.AgentID;
                                        server.UDP.SendPacket(recipient.AgentID, notify, PacketCategory.State);
                                    }
                                }

                                if (senderOnline)
                                {
                                    if (receiverOnline)
                                    {
                                        OnlineNotificationPacket notify = new OnlineNotificationPacket();
                                        notify.AgentBlock            = new OnlineNotificationPacket.AgentBlockBlock[0];
                                        notify.AgentBlock[0]         = new OnlineNotificationPacket.AgentBlockBlock();
                                        notify.AgentBlock[0].AgentID = recipient.AgentID;
                                        server.UDP.SendPacket(agent.AgentID, notify, PacketCategory.State);
                                    }
                                    else
                                    {
                                        OfflineNotificationPacket notify = new OfflineNotificationPacket();
                                        notify.AgentBlock            = new OfflineNotificationPacket.AgentBlockBlock[0];
                                        notify.AgentBlock[0]         = new OfflineNotificationPacket.AgentBlockBlock();
                                        notify.AgentBlock[0].AgentID = recipient.AgentID;
                                        server.UDP.SendPacket(agent.AgentID, notify, PacketCategory.State);
                                    }
                                }
                            }

                            break;
                        }
                    }
                }
            }
        }
Exemplo n.º 6
0
        void AgentRemove(object sender, Agent agent)
        {
            if (OnAgentRemove != null)
                OnAgentRemove(sender, agent);

            Logger.Log("Removing agent " + agent.FullName + " from the scene", Helpers.LogLevel.Info);

            lock (sceneAgents) sceneAgents.Remove(agent.ID);

            // Kill the EventQueue
            RemoveEventQueue(agent.ID);

            // Remove the UDP client
            udp.RemoveClient(agent);

            // Notify everyone in the scene that this agent has gone offline
            OfflineNotificationPacket offline = new OfflineNotificationPacket();
            offline.AgentBlock = new OfflineNotificationPacket.AgentBlockBlock[1];
            offline.AgentBlock[0] = new OfflineNotificationPacket.AgentBlockBlock();
            offline.AgentBlock[0].AgentID = agent.ID;
            udp.BroadcastPacket(offline, PacketCategory.State);
        }