public frmGroupInfo(Group group, SecondLife client)
        {
            InitializeComponent();

            while (!IsHandleCreated)
            {
                // Force handle creation
                IntPtr temp = Handle;
            }

            Group = group;
            Client = client;

            Client.Avatars.OnAvatarNames += new AvatarManager.AvatarNamesCallback(AvatarNamesHandler);

            // Request the group information

            Client.Groups.BeginGetGroupProfile(Group.ID,
                new GroupManager.GroupProfileCallback(GroupProfileHandler));

            Client.Groups.BeginGetGroupMembers(Group.ID,
                new GroupManager.GroupMembersCallback(GroupMembersHandler));

            Client.Groups.BeginGetGroupTitles(Group.ID,
                new GroupManager.GroupTitlesCallback(GroupTitlesHandler));
        }
예제 #2
0
        static void Main(string[] args)
        {
            if (args.Length < 4)
            {
                Console.WriteLine("Usage: Key2Name [loginfirstname] [loginlastname] [password] [key]");
                return;
            }

            SecondLife client = new SecondLife();
            Console.WriteLine("Attempting to connect and login to Second Life.");

            // Login to Second Life
            if (!client.Network.Login(args[0], args[1], args[2], "key2name", "*****@*****.**"))
            {
                // Login failed
                Console.WriteLine("Error logging in: " + client.Network.LoginMessage);
                return;
            }

            AvatarTracker avatarTracker = new AvatarTracker(client);

            LLUUID lookup = new LLUUID();
            LLUUID.TryParse(args[3], out lookup);

            Console.WriteLine("Looking up name for " + lookup.ToStringHyphenated());

            string name = avatarTracker.GetAvatarName(lookup);

            Console.WriteLine("Name: " + name + Environment.NewLine + "Press enter to logout.");
            Console.ReadLine();

            client.Network.Logout();
        }
예제 #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        public void Update(SecondLife client)
        {
            ParcelPropertiesUpdatePacket request = new ParcelPropertiesUpdatePacket();

            request.AgentData.AgentID   = client.Network.AgentID;
            request.AgentData.SessionID = client.Network.SessionID;

            request.ParcelData.Flags   = 0xFFFFFFFF; // TODO: Probably very important
            request.ParcelData.LocalID = this.LocalID;

            request.ParcelData.AuthBuyerID    = this.AuthBuyerID;
            request.ParcelData.Category       = this.Category;
            request.ParcelData.Desc           = Helpers.StringToField(this.Desc);
            request.ParcelData.GroupID        = this.GroupID;
            request.ParcelData.LandingType    = this.LandingType;
            request.ParcelData.MediaAutoScale = this.MediaAutoScale;
            request.ParcelData.MediaID        = this.MediaID;
            request.ParcelData.MediaURL       = Helpers.StringToField(this.MediaURL);
            request.ParcelData.MusicURL       = Helpers.StringToField(this.MusicURL);
            request.ParcelData.Name           = Helpers.StringToField(this.Name);
            request.ParcelData.ParcelFlags    = this.ParcelFlags;
            request.ParcelData.PassHours      = this.PassHours;
            request.ParcelData.PassPrice      = this.PassPrice;
            request.ParcelData.SalePrice      = this.SalePrice;
            request.ParcelData.SnapshotID     = this.SnapshotID;
            request.ParcelData.UserLocation   = this.UserLocation;
            request.ParcelData.UserLookAt     = this.UserLookAt;

            client.Network.SendPacket((Packet)request, Sim);
            //Packet updatePacket = Packets.Parcel.ParcelPropertiesUpdate(client.Protocol, client.Avatar.ID, client.Network.SessionID, this);
            //Sim.SendPacket(updatePacket, true);
        }
예제 #4
0
        public frmGroupInfo(Group group, SecondLife client)
        {
            InitializeComponent();

            while (!IsHandleCreated)
            {
                // Force handle creation
                IntPtr temp = Handle;
            }

            GroupProfileCallback = new GroupManager.GroupProfileCallback(GroupProfileHandler);
            GroupMembersCallback = new GroupManager.GroupMembersCallback(GroupMembersHandler);
            GroupTitlesCallback = new GroupManager.GroupTitlesCallback(GroupTitlesHandler);
            AvatarNamesCallback = new AvatarManager.AvatarNamesCallback(AvatarNamesHandler);
            ImageReceivedCallback = new AssetManager.ImageReceivedCallback(Assets_OnImageReceived);

            Group = group;
            Client = client;
            
            // Register the callbacks for this form
            Client.Assets.OnImageReceived += ImageReceivedCallback;
            Client.Groups.OnGroupProfile += GroupProfileCallback;
            Client.Groups.OnGroupMembers += GroupMembersCallback;
            Client.Groups.OnGroupTitles += GroupTitlesCallback;
            Client.Avatars.OnAvatarNames += AvatarNamesCallback;

            // Request the group information
            Client.Groups.RequestGroupProfile(Group.ID);
            Client.Groups.RequestGroupMembers(Group.ID);
            Client.Groups.RequestGroupTitles(Group.ID);
        }
예제 #5
0
파일: SleekInstance.cs 프로젝트: SObS/SLeek
        public SleekInstance(bool firstInstance)
        {
            this.firstInstance = firstInstance;

            client = new SecondLife();
            client.Settings.ALWAYS_REQUEST_OBJECTS = true;
            client.Settings.ALWAYS_DECODE_OBJECTS = true;
            client.Settings.OBJECT_TRACKING = true;
            client.Settings.ENABLE_SIMSTATS = true;
            client.Settings.FETCH_MISSING_INVENTORY = true;
            client.Settings.MULTIPLE_SIMS = true;
            client.Settings.SEND_AGENT_THROTTLE = true;
            client.Settings.SEND_AGENT_UPDATES = true;

            netcom = new SLNetCom(client);

            imageCache = new ImageCache();
            state = new StateManager(this);
            InitializeConfig();

            mainForm = new frmMain(this);
            mainForm.InitializeControls();
            tabsConsole = mainForm.TabConsole;

            Application.ApplicationExit += new EventHandler(Application_ApplicationExit);
        }
예제 #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="mapFile"></param>
        /// <param name="client"></param>
        public ProtocolManager(string mapFile, SecondLife client)
        {
            Client = client;

            // Initialize the map arrays
            LowMaps    = new MapPacket[65536];
            MediumMaps = new MapPacket[256];
            HighMaps   = new MapPacket[256];

            // Build the type size hash table
            TypeSizes = new Dictionary <FieldType, int>();
            TypeSizes.Add(FieldType.U8, 1);
            TypeSizes.Add(FieldType.U16, 2);
            TypeSizes.Add(FieldType.U32, 4);
            TypeSizes.Add(FieldType.U64, 8);
            TypeSizes.Add(FieldType.S8, 1);
            TypeSizes.Add(FieldType.S16, 2);
            TypeSizes.Add(FieldType.S32, 4);
            TypeSizes.Add(FieldType.F32, 4);
            TypeSizes.Add(FieldType.F64, 8);
            TypeSizes.Add(FieldType.LLUUID, 16);
            TypeSizes.Add(FieldType.BOOL, 1);
            TypeSizes.Add(FieldType.LLVector3, 12);
            TypeSizes.Add(FieldType.LLVector3d, 24);
            TypeSizes.Add(FieldType.LLVector4, 16);
            TypeSizes.Add(FieldType.LLQuaternion, 16);
            TypeSizes.Add(FieldType.IPADDR, 4);
            TypeSizes.Add(FieldType.IPPORT, 2);
            TypeSizes.Add(FieldType.Variable, -1);
            TypeSizes.Add(FieldType.Fixed, -2);

            KeywordPositions = new Dictionary <string, int>();
            LoadMapFile(mapFile);
        }
예제 #7
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="texture"></param>
 public PrimObject(SecondLife client, LLUUID texture)
 {
     Client   = client;
     PCode    = PCode.Prim;
     Textures = new TextureEntry();
     Textures.DefaultTexture.TextureID = texture;
 }
예제 #8
0
        public FriendsConsole(SleekInstance instance)
        {
            InitializeComponent();

            this.instance = instance;
            client = this.instance.Client;
        }
예제 #9
0
    public static void Main(string[] args)
    {
        // configure the proxy
        client = new SecondLife("../data/keywords.txt", "../data/message_template.msg");
        protocolManager = client.Protocol;
        ProxyConfig proxyConfig = new ProxyConfig("Analyst", "*****@*****.**", protocolManager, args);
        proxy = new Proxy(proxyConfig);

        // build the table of /command delegates
        InitializeCommandDelegates();

        // add delegates for login
        proxy.SetLoginRequestDelegate(new XmlRpcRequestDelegate(LoginRequest));
        proxy.SetLoginResponseDelegate(new XmlRpcResponseDelegate(LoginResponse));

        // add a delegate for outgoing chat
        proxy.AddDelegate("ChatFromViewer", Direction.Incoming, new PacketDelegate(ChatFromViewerIn));
        proxy.AddDelegate("ChatFromViewer", Direction.Outgoing, new PacketDelegate(ChatFromViewerOut));

        //  handle command line arguments
        foreach (string arg in args)
            if (arg == "--log-all")
                LogAll();
            else if (arg == "--log-login")
                logLogin = true;

        // start the proxy
        proxy.Start();
    }
예제 #10
0
        /// <summary>
        /// Represents other avatars
        /// </summary>
        /// <param name="client"></param>
        public AvatarManager(SecondLife client)
        {
            Client = client;

            // Avatar appearance callback
            Client.Network.RegisterCallback(PacketType.AvatarAppearance, new NetworkManager.PacketCallback(AvatarAppearanceHandler));

            // Avatar profile callbacks
            Client.Network.RegisterCallback(PacketType.AvatarPropertiesReply, new NetworkManager.PacketCallback(AvatarPropertiesHandler));
            // Client.Network.RegisterCallback(PacketType.AvatarStatisticsReply, new NetworkManager.PacketCallback(AvatarStatisticsHandler));
            Client.Network.RegisterCallback(PacketType.AvatarInterestsReply, new NetworkManager.PacketCallback(AvatarInterestsHandler));

            // Avatar group callback
            Client.Network.RegisterCallback(PacketType.AvatarGroupsReply, new NetworkManager.PacketCallback(AvatarGroupsHandler));

            // Viewer effect callback
            Client.Network.RegisterCallback(PacketType.ViewerEffect, new NetworkManager.PacketCallback(ViewerEffectHandler));

            // Other callbacks
            Client.Network.RegisterCallback(PacketType.UUIDNameReply, new NetworkManager.PacketCallback(AvatarNameHandler));
            Client.Network.RegisterCallback(PacketType.AvatarPickerReply, new NetworkManager.PacketCallback(AvatarPickerReplyHandler));
            Client.Network.RegisterCallback(PacketType.AvatarAnimation, new NetworkManager.PacketCallback(AvatarAnimationHandler));

            // Picks callbacks
            Client.Network.RegisterCallback(PacketType.AvatarPicksReply, new NetworkManager.PacketCallback(AvatarPicksHandler));
            Client.Network.RegisterCallback(PacketType.PickInfoReply, new NetworkManager.PacketCallback(PickInfoHandler));
        }
예제 #11
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        public GroupManager(SecondLife client)
        {
            Client = client;

            GroupProfileCallbacks             = new Dictionary <LLUUID, GroupProfileCallback>();
            GroupMembersCallbacks             = new Dictionary <LLUUID, GroupMembersCallback>();
            GroupRolesCallbacks               = new Dictionary <LLUUID, GroupRolesCallback>();
            GroupRolesMembersCallbacks        = new Dictionary <LLUUID, GroupRolesMembersCallback>();
            GroupTitlesCallbacks              = new Dictionary <LLUUID, GroupTitlesCallback>();
            GroupAccountSummaryCallbacks      = new Dictionary <LLUUID, GroupAccountSummaryCallback>();
            GroupAccountDetailsCallbacks      = new Dictionary <LLUUID, GroupAccountDetailsCallback>();
            GroupAccountTransactionsCallbacks = new Dictionary <LLUUID, GroupAccountTransactionsCallback>();

            GroupMembersCaches      = new Dictionary <LLUUID, Dictionary <LLUUID, GroupMember> >();
            GroupRolesCaches        = new Dictionary <LLUUID, Dictionary <LLUUID, GroupRole> >();
            GroupRolesMembersCaches = new Dictionary <LLUUID, List <KeyValuePair <LLUUID, LLUUID> > >();

            Client.Network.RegisterCallback(PacketType.AgentGroupDataUpdate, new PacketCallback(GroupDataHandler));
            Client.Network.RegisterCallback(PacketType.GroupTitlesReply, new PacketCallback(GroupTitlesHandler));
            Client.Network.RegisterCallback(PacketType.GroupProfileReply, new PacketCallback(GroupProfileHandler));
            Client.Network.RegisterCallback(PacketType.GroupMembersReply, new PacketCallback(GroupMembersHandler));
            Client.Network.RegisterCallback(PacketType.GroupRoleDataReply, new PacketCallback(GroupRoleDataHandler));
            Client.Network.RegisterCallback(PacketType.GroupRoleMembersReply, new PacketCallback(GroupRoleMembersHandler));
            Client.Network.RegisterCallback(PacketType.GroupActiveProposalItemReply, new PacketCallback(GroupActiveProposalItemHandler));
            Client.Network.RegisterCallback(PacketType.GroupVoteHistoryItemReply, new PacketCallback(GroupVoteHistoryItemHandler));
            Client.Network.RegisterCallback(PacketType.GroupAccountSummaryReply, new PacketCallback(GroupAccountSummaryHandler));
            Client.Network.RegisterCallback(PacketType.GroupAccountDetailsReply, new PacketCallback(GroupAccountDetailsHandler));
            Client.Network.RegisterCallback(PacketType.GroupAccountTransactionsReply, new PacketCallback(GroupAccountTransactionsHandler));
        }
예제 #12
0
        static void Main(string[] args)
        {
            SecondLife client = new SecondLife();
            if (args.Length < 4)
            {
                Console.WriteLine("Usage: Key2Name [loginfirstname] [loginlastname] [password] [key]");
                return;
            }
            Console.WriteLine("Attempting to connect and login to Second Life.");

            // Setup Login to Second Life
            Dictionary<string, object> loginParams = client.Network.DefaultLoginValues(args[0],
                args[1], args[2], "00:00:00:00:00:00", "last", "Win", "0", "key2name",
                "*****@*****.**");
            Dictionary<string, object> loginReply = new Dictionary<string, object>();
            if (!client.Network.Login(loginParams))
            {
                // Login failed
                Console.WriteLine("Error logging in: " + client.Network.LoginError);
                return;
            }
            AvatarTracker avatarTracker = new AvatarTracker(client);
            LLUUID lookup = new LLUUID(args[3]);
            Console.WriteLine("Looking up name for " + lookup.ToStringHyphenated());
            string name = avatarTracker.GetAvatarName(lookup);
            Console.WriteLine("Name: " + name + ". Press enter to logout.");
            Console.ReadLine();
            client.Network.Logout();
        }
예제 #13
0
 /// <summary>
 /// Aims at the specified position, enters mouselook, presses and
 /// releases the left mouse button, and leaves mouselook
 /// </summary>
 /// <param name="target">Target to shoot at</param>
 /// <returns></returns>
 public static bool Shoot(SecondLife client, LLVector3 target)
 {
     if (client.Self.Movement.TurnToward(target))
         return Shoot(client);
     else
         return false;
 }
예제 #14
0
		static void Main(string[] args)
		{
			SecondLife client;

			if (args.Length < 5)
			{
				Console.WriteLine("Usage: name2key [loginfirstname] [loginlastname] [password] [firstname] [lastname]");
				return;
			}

			client = new SecondLife();

			// Setup the callback
            client.Directory.OnDirPeopleReply += new DirectoryManager.DirPeopleReplyCallback(DirQueryHandler);

			if (!client.Network.Login(args[0], args[1], args[2], "name2key", "*****@*****.**"))
			{
				// Login failed
				Console.WriteLine("ERROR: " + client.Network.LoginMessage);
				return;
			}

			// Send the Query
            queryID = client.Directory.StartPeopleSearch(DirectoryManager.DirFindFlags.People, args[3] + " " + args[4], 0);
            
            // Wait for the event to trigger
            queryEvent.WaitOne(8000, false);

			client.Network.Logout();
		}
예제 #15
0
        /// <summary>
        /// Enters mouselook, presses and releases the left mouse button, and leaves mouselook
        /// </summary>
        /// <returns></returns>
        public static bool Shoot(SecondLife client)
        {
            if (client.Settings.SEND_AGENT_UPDATES)
            {
                client.Self.Movement.Mouselook = true;
                client.Self.Movement.MLButtonDown = true;
                client.Self.Movement.SendUpdate();

                client.Self.Movement.MLButtonUp = true;
                client.Self.Movement.MLButtonDown = false;
                client.Self.Movement.FinishAnim = true;
                client.Self.Movement.SendUpdate();

                client.Self.Movement.Mouselook = false;
                client.Self.Movement.MLButtonUp = false;
                client.Self.Movement.FinishAnim = false;
                client.Self.Movement.SendUpdate();

                return true;
            }
            else
            {
                Logger.Log("Attempted Shoot but agent updates are disabled", Helpers.LogLevel.Warning, client);
                return false;
            }
        }
        public AppearanceManager(SecondLife client)
        {
            Client = client;
            AManager = client.Assets;

            RegisterCallbacks();
        }
예제 #17
0
 /// <summary>
 /// Constructor for EstateTools class
 /// </summary>
 /// <param name="client"></param>
 public EstateTools(SecondLife client)
 {
     Client = client;
     Client.Network.RegisterCallback(PacketType.LandStatReply, new NetworkManager.PacketCallback(LandStatReplyHandler));
     Client.Network.RegisterCallback(PacketType.EstateOwnerMessage, new NetworkManager.PacketCallback(EstateOwnerMessageHandler));
     Client.Network.RegisterCallback(PacketType.EstateCovenantReply, new NetworkManager.PacketCallback(EstateCovenantReplyHandler));
 }
        public WhisperCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "whisper";
            Description = "Whisper something.";
        }
예제 #19
0
파일: SLNetCom.cs 프로젝트: SObS/SLeek
        public SLNetCom(SecondLife client)
        {
            this.client = client;
            loginOptions = new LoginOptions();

            AddClientEvents();
            AddPacketCallbacks();
        }
        public SetAppearanceCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "setapp";
            Description = "Set appearance to what's stored in the DB.";
        }
        public QuitCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "quit";
            Description = "Log all avatars out and shut down";
        }
        public void AddClient(SecondLife client)
        {
            Global.ClientsMutex.WaitOne();
            Global.Clients.Add(client);
            Global.ClientsMutex.ReleaseMutex();

            Overview.ClientAdded(client);
        }
예제 #23
0
        public SLProtocol()
        {
            m_user = new SecondLife();

            m_user.Network.OnConnected += new NetworkManager.ConnectedCallback(SLConnected);
            m_user.Terrain.OnLandPatch += new TerrainManager.LandPatchCallback(SLLandPatch);
            m_user.Self.OnChat += new AgentManager.ChatCallback(SLChat);
        }
        public ExportOutfitCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "exportoutfit";
            Description = "Exports an avatars outfit to an xml file. Usage: exportoutfit avataruuid outputfile.xml";
        }
예제 #25
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of type SecondLife to associate with this GridManager instance</param>
        public GridManager(SecondLife client)
        {
            Client       = client;
            SunDirection = LLVector3.Zero;

            Client.Network.RegisterCallback(PacketType.MapBlockReply, new NetworkManager.PacketCallback(MapBlockReplyHandler));
            Client.Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, new NetworkManager.PacketCallback(TimeMessageHandler));
        }
예제 #26
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="client"></param>
        public AppearanceManager(SecondLife client)
        {
            Client = client;
            Client.Network.RegisterCallback(libsecondlife.Packets.PacketType.AgentWearablesUpdate, new NetworkManager.PacketCallback(AgentWearablesUpdateCallbackHandler));

            AManager = client.Assets;
            AManager.TransferRequestCompletedEvent += new AssetManager.On_TransferRequestCompleted(AManager_TransferRequestCompletedEvent);
        }
        public FollowCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "follow";
            Description = "Follow another avatar. (usage: follow [FirstName LastName])  If no target is set then will follow master.";
        }
        public LocationCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "location";
            Description = "Show the location.";
        }
        public PrimCountCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "primCount";
            Description = "Shows the number of prims that have been received.";
        }
        public SitCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "sit";
            Description = "Attempt to sit on the closest prim";
        }
        public LogoutCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "logout";
            Description = "Log this avatar out";
        }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of type SecondLife to associate with this GridManager instance</param>
        public GridManager(SecondLife client)
        {
            Client = client;
            SunDirection = LLVector3.Zero;

            Client.Network.RegisterCallback(PacketType.MapBlockReply, new NetworkManager.PacketCallback(MapBlockReplyHandler));
            Client.Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, new NetworkManager.PacketCallback(TimeMessageHandler));
        }
        public LoadCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "load";
            Description = "Loads commands from a dll. (Usage: load AssemblyNameWithoutExtension)";
        }
        public FindSimCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "findsim";
            Description = "Searches for a simulator and returns information about it. Usage: findsim [Simulator Name]";
        }
        public JumpCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "jump";
            Description = "Teleports to the specified height. (e.g. \"jump 1000\")";
        }
        public UptimeCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "uptime";
            Description = "Shows the login name, login time and length of time logged on.";
        }
        public PacketLogCommand(TestClient testClient)
        {
            TestClient = testClient;
            Client = (SecondLife)TestClient;

            Name = "packetlog";
            Description = "Logs a given number of packets to an xml file. Usage: packetlog 10 tenpackets.xml";
        }
예제 #38
0
        public SoundManager(SecondLife client)
        {
            Client = client;

            Client.Network.RegisterCallback(PacketType.AttachedSound, new NetworkManager.PacketCallback(AttachedSoundHandler));
            Client.Network.RegisterCallback(PacketType.AttachedSoundGainChange, new NetworkManager.PacketCallback(AttachedSoundGainChangeHandler));
            Client.Network.RegisterCallback(PacketType.PreloadSound, new NetworkManager.PacketCallback(PreloadSoundHandler));
            Client.Network.RegisterCallback(PacketType.SoundTrigger, new NetworkManager.PacketCallback(SoundTriggerHandler));
        }
예제 #39
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of type SecondLife to associate with this GridManager instance</param>
        public GridManager(SecondLife client)
        {
            Client       = client;
            Regions      = new Dictionary <string, GridRegion>();
            SunDirection = new LLVector3();

            Client.Network.RegisterCallback(PacketType.MapBlockReply, new PacketCallback(MapBlockReplyHandler));
            Client.Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, new PacketCallback(TimeMessageHandler));
        }
예제 #40
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of type SecondLife to associate with this GridManager instance</param>
        public GridManager(SecondLife client)
        {
            Client = client;

            Client.Network.RegisterCallback(PacketType.MapBlockReply, new NetworkManager.PacketCallback(MapBlockReplyHandler));
            Client.Network.RegisterCallback(PacketType.MapItemReply, new NetworkManager.PacketCallback(MapItemReplyHandler));
            Client.Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, new NetworkManager.PacketCallback(TimeMessageHandler));
            Client.Network.RegisterCallback(PacketType.CoarseLocationUpdate, new NetworkManager.PacketCallback(CoarseLocationHandler));
        }
예제 #41
0
            /// <summary>Default constructor</summary>
            public AgentMovement(SecondLife client)
            {
                Client = client;
                Camera = new AgentCamera();

                updateInterval = Settings.DEFAULT_AGENT_UPDATE_INTERVAL;
                updateTimer    = new Timer(new TimerCallback(UpdateTimer_Elapsed), null, Settings.DEFAULT_AGENT_UPDATE_INTERVAL,
                                           Settings.DEFAULT_AGENT_UPDATE_INTERVAL);
            }
예제 #42
0
 /// <summary>Constructor for class MainAvatarStatus</summary>
 public MainAvatarStatus(SecondLife client)
 {
     Client               = client;
     UpdateTimer          = new Timer();
     UpdateTimer.Elapsed += new ElapsedEventHandler(UpdateTimer_Elapsed);
     UpdateTimer.Interval = 500;
     //Update Timer Disabled By Default --Jesse Malthus
     UpdateTimer.Enabled = false;
 }
예제 #43
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        public Region(SecondLife client)
        {
            Estate        = new EstateTools(client);
            Client        = client;
            ParcelOverlay = new byte[4096];
            ParcelMarked  = new int[64, 64];

            Parcels = new Dictionary <int, Parcel>();
        }
예제 #44
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        public ObjectManager(SecondLife client)
        {
            Client = client;

            Client.Network.RegisterCallback(PacketType.ObjectUpdate, new PacketCallback(UpdateHandler));
            Client.Network.RegisterCallback(PacketType.ImprovedTerseObjectUpdate, new PacketCallback(TerseUpdateHandler));
            Client.Network.RegisterCallback(PacketType.ObjectUpdateCompressed, new PacketCallback(CompressedUpdateHandler));
            Client.Network.RegisterCallback(PacketType.ObjectUpdateCached, new PacketCallback(CachedUpdateHandler));
            Client.Network.RegisterCallback(PacketType.KillObject, new PacketCallback(KillObjectHandler));
        }
예제 #45
0
        public DirectoryManager(SecondLife client)
        {
            Client = client;

            Client.Network.RegisterCallback(PacketType.DirClassifiedReply, new NetworkManager.PacketCallback(DirClassifiedReplyHandler));
            Client.Network.RegisterCallback(PacketType.DirLandReply, new NetworkManager.PacketCallback(DirLandReplyHandler));
            Client.Network.RegisterCallback(PacketType.DirPeopleReply, new NetworkManager.PacketCallback(DirPeopleReplyHandler));
            Client.Network.RegisterCallback(PacketType.DirGroupsReply, new NetworkManager.PacketCallback(DirGroupsReplyHandler));
            Client.Network.RegisterCallback(PacketType.PlacesReply, new NetworkManager.PacketCallback(PlacesReplyHandler));
        }
예제 #46
0
 public Inventory(SecondLife client, InventoryManager manager, LLUUID owner)
 {
     Client  = client;
     Manager = manager;
     _Owner  = owner;
     if (owner == LLUUID.Zero)
     {
         Logger.Log("Inventory owned by nobody!", Helpers.LogLevel.Warning, Client);
     }
     Items = new Dictionary <LLUUID, InventoryNode>();
 }
예제 #47
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        public void GetDwell(SecondLife client)
        {
            ParcelDwellRequestPacket request = new ParcelDwellRequestPacket();

            request.AgentData.AgentID   = client.Network.AgentID;
            request.AgentData.SessionID = client.Network.SessionID;
            request.Data.LocalID        = LocalID;
            request.Data.ParcelID       = LLUUID.Zero;

            client.Network.SendPacket((Packet)request, Sim);
        }
예제 #48
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        /// <returns></returns>
        public bool Reclaim(SecondLife client)
        {
            ParcelReclaimPacket request = new ParcelReclaimPacket();

            request.AgentData.AgentID   = client.Network.AgentID;
            request.AgentData.SessionID = client.Network.SessionID;

            request.Data.LocalID = this.LocalID;

            client.Network.SendPacket((Packet)request, Sim);
            return(true);
        }
예제 #49
0
        /// <summary>
        /// Send a log message to the logging engine
        /// </summary>
        /// <param name="message">The log message</param>
        /// <param name="level">The severity of the log entry</param>
        /// <param name="client">Instance of the client</param>
        /// <param name="exception">Exception that was raised</param>
        public static void Log(object message, Helpers.LogLevel level, SecondLife client, Exception exception)
        {
            if (client != null && client.Settings.LOG_NAMES)
            {
                message = String.Format("<{0}>: {1}", client.Self.Name, message);
            }

            if (OnLogMessage != null)
            {
                OnLogMessage(message, level);
            }

            switch (level)
            {
            case Helpers.LogLevel.Debug:
                if (Settings.LOG_LEVEL == Helpers.LogLevel.Debug)
                {
                    LogInstance.Debug(message, exception);
                }
                break;

            case Helpers.LogLevel.Info:
                if (Settings.LOG_LEVEL == Helpers.LogLevel.Debug ||
                    Settings.LOG_LEVEL == Helpers.LogLevel.Info)
                {
                    LogInstance.Info(message, exception);
                }
                break;

            case Helpers.LogLevel.Warning:
                if (Settings.LOG_LEVEL == Helpers.LogLevel.Debug ||
                    Settings.LOG_LEVEL == Helpers.LogLevel.Info ||
                    Settings.LOG_LEVEL == Helpers.LogLevel.Warning)
                {
                    LogInstance.Warn(message, exception);
                }
                break;

            case Helpers.LogLevel.Error:
                if (Settings.LOG_LEVEL == Helpers.LogLevel.Debug ||
                    Settings.LOG_LEVEL == Helpers.LogLevel.Info ||
                    Settings.LOG_LEVEL == Helpers.LogLevel.Warning ||
                    Settings.LOG_LEVEL == Helpers.LogLevel.Error)
                {
                    LogInstance.Error(message, exception);
                }
                break;

            default:
                break;
            }
        }
예제 #50
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client">Reference to the SecondLife client</param>
        /// <param name="address">IPEndPoint of the simulator</param>
        /// <param name="handle">handle of the simulator</param>
        public Simulator(SecondLife client, IPEndPoint address, ulong handle)
            : base(address)
        {
            Client = client;

            ipEndPoint    = address;
            Handle        = handle;
            Estate        = new EstateTools(Client);
            Network       = Client.Network;
            PacketArchive = new Queue <uint>(Settings.PACKET_ARCHIVE_SIZE);
            InBytes       = new Queue <ulong>(Client.Settings.STATS_QUEUE_SIZE);
            OutBytes      = new Queue <ulong>(Client.Settings.STATS_QUEUE_SIZE);
        }
예제 #51
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        /// <param name="groupID"></param>
        /// <returns></returns>
        public bool Deed(SecondLife client, LLUUID groupID)
        {
            ParcelDeedToGroupPacket request = new ParcelDeedToGroupPacket();

            request.AgentData.AgentID   = client.Network.AgentID;
            request.AgentData.SessionID = client.Network.SessionID;

            request.Data.LocalID = this.LocalID;
            request.Data.GroupID = groupID;

            client.Network.SendPacket((Packet)request, Sim);
            return(true);
        }
예제 #52
0
        /// <summary>
        /// This constructor is intened to for use only the the libsecondlife framework
        /// </summary>
        /// <param name="client"></param>
        public FriendsManager(SecondLife client)
        {
            Client = client;

            Client.Network.OnConnected   += new NetworkManager.ConnectedCallback(Network_OnConnect);
            Client.Avatars.OnAvatarNames += new AvatarManager.AvatarNamesCallback(Avatars_OnAvatarNames);
            Client.Self.OnInstantMessage += new AgentManager.InstantMessageCallback(MainAvatar_InstantMessage);

            Client.Network.RegisterCallback(PacketType.OnlineNotification, OnlineNotificationHandler);
            Client.Network.RegisterCallback(PacketType.OfflineNotification, OfflineNotificationHandler);
            Client.Network.RegisterCallback(PacketType.ChangeUserRights, ChangeUserRightsHandler);
            Client.Network.RegisterCallback(PacketType.TerminateFriendship, TerminateFriendshipHandler);

            Client.Network.RegisterLoginResponseCallback(new NetworkManager.LoginResponseCallback(Network_OnLoginResponse),
                                                         new string[] { "buddy-list" });
        }
예제 #53
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        /// <param name="forGroup"></param>
        /// <param name="groupID"></param>
        /// <returns></returns>
        public bool Buy(SecondLife client, bool forGroup, LLUUID groupID, bool removeContribution)
        {
            ParcelBuyPacket request = new ParcelBuyPacket();

            request.AgentData.AgentID   = client.Network.AgentID;
            request.AgentData.SessionID = client.Network.SessionID;

            request.Data.Final              = true;
            request.Data.GroupID            = groupID;
            request.Data.LocalID            = this.LocalID;
            request.Data.IsGroupOwned       = forGroup;
            request.Data.RemoveContribution = removeContribution;

            client.Network.SendPacket((Packet)request, Sim);
            return(true);
        }
예제 #54
0
        public static void DebugLog(object message, SecondLife client)
        {
            if (Settings.LOG_LEVEL == Helpers.LogLevel.Debug)
            {
                if (client != null && client.Settings.LOG_NAMES)
                {
                    message = String.Format("<{0}>: {1}", client.Self.Name, message);
                }

                if (OnLogMessage != null)
                {
                    OnLogMessage(message, Helpers.LogLevel.Debug);
                }

                LogInstance.Debug(message);
            }
        }
예제 #55
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        public TerrainManager(SecondLife client)
        {
            Client = client;

            // Initialize the decompression tables
            BuildDequantizeTable16();
            BuildDequantizeTable32();
            SetupCosines16();
            SetupCosines32();
            BuildCopyMatrix16();
            BuildCopyMatrix32();

            // Not used by clients
            BuildQuantizeTable16();

            Client.Network.RegisterCallback(PacketType.LayerData, new NetworkManager.PacketCallback(LayerDataHandler));
        }
예제 #56
0
        /// <summary>
        /// Parcel (subdivided simulator lots) Subsystem
        /// </summary>
        /// <param name="client"></param>
        public ParcelManager(SecondLife client)
        {
            Client         = client;
            ParcelsForSale = new List <DirectoryParcel>();

            // Setup the timer
            DirLandTimer          = new Timer(8000);
            DirLandTimer.Elapsed += new ElapsedEventHandler(DirLandTimerEvent);
            DirLandTimeout        = false;

            // Setup the callbacks
            Client.Network.RegisterCallback(PacketType.DirLandReply, new NetworkManager.PacketCallback(DirLandReplyHandler));
            Client.Network.RegisterCallback(PacketType.ParcelInfoReply, new NetworkManager.PacketCallback(ParcelInfoReplyHandler));
            Client.Network.RegisterCallback(PacketType.ParcelProperties, new NetworkManager.PacketCallback(ParcelPropertiesHandler));
            Client.Network.RegisterCallback(PacketType.ParcelDwellReply, new NetworkManager.PacketCallback(ParcelDwellReplyHandler));

            ParcelInfoParcel = null;
        }
예제 #57
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="client"></param>
        /// <param name="returnType"></param>
        public void ReturnObjects(SecondLife client, uint returnType)
        {
            // TODO: ENUM for returnType

            ParcelReturnObjectsPacket request = new ParcelReturnObjectsPacket();

            request.AgentData.AgentID   = client.Network.AgentID;
            request.AgentData.SessionID = client.Network.SessionID;

            request.ParcelData.LocalID    = this.LocalID;
            request.ParcelData.ReturnType = returnType;

            // TODO: Handling of TaskIDs and OwnerIDs
            request.OwnerIDs = new ParcelReturnObjectsPacket.OwnerIDsBlock[0];
            request.TaskIDs  = new ParcelReturnObjectsPacket.TaskIDsBlock[1];

            client.Network.SendPacket((Packet)request, Sim);
        }
예제 #58
0
        /// <summary>
        /// Represents other avatars
        /// </summary>
        /// <param name="client"></param>
        public AvatarManager(SecondLife client)
        {
            Client = client;

            // Friend notification callback
            NetworkManager.PacketCallback callback = new NetworkManager.PacketCallback(FriendNotificationHandler);
            Client.Network.RegisterCallback(PacketType.OnlineNotification, callback);
            Client.Network.RegisterCallback(PacketType.OfflineNotification, callback);

            // Avatar profile callbacks
            Client.Network.RegisterCallback(PacketType.AvatarPropertiesReply, new NetworkManager.PacketCallback(AvatarPropertiesHandler));
            Client.Network.RegisterCallback(PacketType.AvatarStatisticsReply, new NetworkManager.PacketCallback(AvatarStatisticsHandler));
            Client.Network.RegisterCallback(PacketType.AvatarInterestsReply, new NetworkManager.PacketCallback(AvatarInterestsHandler));

            // Other callbacks
            Client.Network.RegisterCallback(PacketType.UUIDNameReply, new NetworkManager.PacketCallback(AvatarNameHandler));
            Client.Network.RegisterCallback(PacketType.AvatarPickerReply, new NetworkManager.PacketCallback(AvatarPickerReplyHandler));
        }
예제 #59
0
        public AvatarManager(SecondLife client)
        {
            Client  = client;
            Avatars = new Dictionary <LLUUID, Avatar>();
            //Callback Dictionaries
            AvatarPropertiesCallbacks = new Dictionary <LLUUID, AvatarPropertiesCallback>();
            AvatarStatisticsCallbacks = new Dictionary <LLUUID, AvatarStatisticsCallback>();
            AvatarIntrestsCallbacks   = new Dictionary <LLUUID, AvatarIntrestsCallback>();
            // Friend notification callback
            PacketCallback callback = new PacketCallback(FriendNotificationHandler);

            Client.Network.RegisterCallback(PacketType.OnlineNotification, callback);
            Client.Network.RegisterCallback(PacketType.OfflineNotification, callback);
            Client.Network.RegisterCallback(PacketType.UUIDNameReply, new PacketCallback(GetAgentNameHandler));
            Client.Network.RegisterCallback(PacketType.AvatarPropertiesReply, new PacketCallback(AvatarPropertiesHandler));
            Client.Network.RegisterCallback(PacketType.AvatarStatisticsReply, new PacketCallback(AvatarStatisticsHandler));
            Client.Network.RegisterCallback(PacketType.AvatarInterestsReply, new PacketCallback(AvatarIntrestsHandler));
        }
예제 #60
0
        /// <summary>
        /// Constructor, aka 'CallBack Central' - Setup callbacks for packets related to our avatar
        /// </summary>
        /// <param name="client"></param>
        public MainAvatar(SecondLife client)
        {
            PacketCallback callback;

            Client          = client;
            TeleportMessage = "";

            // Create emtpy vectors for now
            HomeLookAt = HomePosition = Position = LookAt = new LLVector3();
            Rotation   = new LLQuaternion();

            // Coarse location callback
            Client.Network.RegisterCallback(PacketType.CoarseLocationUpdate, new PacketCallback(CoarseLocationHandler));

            // Teleport callbacks
            callback = new PacketCallback(TeleportHandler);
            Client.Network.RegisterCallback(PacketType.TeleportStart, callback);
            Client.Network.RegisterCallback(PacketType.TeleportProgress, callback);
            Client.Network.RegisterCallback(PacketType.TeleportFailed, callback);
            Client.Network.RegisterCallback(PacketType.TeleportFinish, callback);

            // Instant Message callback
            Client.Network.RegisterCallback(PacketType.ImprovedInstantMessage, new PacketCallback(InstantMessageHandler));

            // Chat callback
            Client.Network.RegisterCallback(PacketType.ChatFromSimulator, new PacketCallback(ChatHandler));

            TeleportTimer          = new Timer(18000);
            TeleportTimer.Elapsed += new ElapsedEventHandler(TeleportTimerEvent);
            TeleportTimeout        = false;

            // Movement complete callback
            Client.Network.RegisterCallback(PacketType.AgentMovementComplete, new PacketCallback(MovementCompleteHandler));

            // Health callback
            Client.Network.RegisterCallback(PacketType.HealthMessage, new PacketCallback(HealthHandler));

            // Money callbacks
            callback = new PacketCallback(BalanceHandler);
            Client.Network.RegisterCallback(PacketType.MoneyBalanceReply, callback);
            Client.Network.RegisterCallback(PacketType.MoneySummaryReply, callback);
            Client.Network.RegisterCallback(PacketType.AdjustBalance, callback);
        }