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));
}
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();
}
/// <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);
}
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);
}
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);
}
/// <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);
}
/// <summary>
///
/// </summary>
/// <param name="texture"></param>
public PrimObject(SecondLife client, LLUUID texture)
{
Client = client;
PCode = PCode.Prim;
Textures = new TextureEntry();
Textures.DefaultTexture.TextureID = texture;
}
public FriendsConsole(SleekInstance instance)
{
InitializeComponent();
this.instance = instance;
client = this.instance.Client;
}
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();
}
/// <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));
}
/// <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));
}
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();
}
/// <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;
}
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();
}
/// <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();
}
/// <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.";
}
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);
}
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";
}
/// <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));
}
/// <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";
}
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));
}
/// <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));
}
/// <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));
}
/// <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);
}
/// <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;
}
/// <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>();
}
/// <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));
}
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));
}
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>();
}
/// <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);
}
/// <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);
}
/// <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;
}
}
/// <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);
}
/// <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);
}
/// <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" });
}
/// <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);
}
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);
}
}
/// <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));
}
/// <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;
}
/// <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);
}
/// <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));
}
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));
}
/// <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);
}
