From 5104a360c3270b4d70fc6242d9b8b9aa96a80e25 Mon Sep 17 00:00:00 2001
From: Madpeter <57852827+Madpeterz@users.noreply.github.com>
Date: Tue, 25 Jun 2024 23:46:33 +0100
Subject: [PATCH] RLV support

---
 Dockerfile                                    |    4 +-
 SecondBotEvents/Commands/Self.cs              |    6 +-
 SecondBotEvents/Config/InteractionConfig.cs   |    2 +-
 SecondBotEvents/Config/RlvConfig.cs           |   10 -
 SecondBotEvents/EventsSecondBot.cs            |    5 +
 SecondBotEvents/RLV/RLVAttachmentInfo.cs      |   19 +
 SecondBotEvents/RLV/RLVEventArgs.cs           |   34 +
 SecondBotEvents/RLV/RLVRule.cs                |   39 +
 .../Services/CurrentOutfitFolder.cs           |  626 ++++++++++
 SecondBotEvents/Services/HomeboundService.cs  |    7 +-
 SecondBotEvents/Services/RLVService.cs        | 1092 +++++++++++++++++
 11 files changed, 1828 insertions(+), 16 deletions(-)
 create mode 100644 SecondBotEvents/RLV/RLVAttachmentInfo.cs
 create mode 100644 SecondBotEvents/RLV/RLVEventArgs.cs
 create mode 100644 SecondBotEvents/RLV/RLVRule.cs
 create mode 100644 SecondBotEvents/Services/CurrentOutfitFolder.cs
 create mode 100644 SecondBotEvents/Services/RLVService.cs

diff --git a/Dockerfile b/Dockerfile
index 1c5ecc2..2a43216 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -89,7 +89,9 @@ ENV basic_Username='' \
 	events_HideStatusOutput='false' \
 	homebound_HideStatusOutput='false' \
 	http_HideStatusOutput='false' \
-	interaction_HideStatusOutput='false'
+	interaction_HideStatusOutput='false' \
+	rlv_Enabled='false' \
+	rlv_HideStatusOutput='false'
 	
 
 EXPOSE 80
diff --git a/SecondBotEvents/Commands/Self.cs b/SecondBotEvents/Commands/Self.cs
index 3091edd..3c0dde4 100644
--- a/SecondBotEvents/Commands/Self.cs
+++ b/SecondBotEvents/Commands/Self.cs
@@ -86,17 +86,17 @@ namespace SecondBotEvents.Commands
         [About("Makes the bot sit on the ground or on a object if it can see it")]
         [ReturnHints("ok")]
         [ReturnHintsFailure("Invaild object UUID")]
-        [ArgHints("target", "ground or a object UUID")]
+        [ArgHints("target", "a object UUID anything or nothing will also work")]
         public object Sit(string target)
         {
-            if (target == "ground")
+            if ((target == "ground") || (target == UUID.Zero.ToString()))
             {
                 GetClient().Self.SitOnGround();
                 return BasicReply("ok", new [] { target });
             }
             if(UUID.TryParse(target,out UUID objectuuid) == false)
             {
-                return Failure("Invaild object UUID", new [] { target });
+                return Failure("Invaild object uuid and not ground");
             }
             GetClient().Self.RequestSit(objectuuid, Vector3.Zero);
             return BasicReply("ok", new [] { target });
diff --git a/SecondBotEvents/Config/InteractionConfig.cs b/SecondBotEvents/Config/InteractionConfig.cs
index 0f10f13..9847317 100644
--- a/SecondBotEvents/Config/InteractionConfig.cs
+++ b/SecondBotEvents/Config/InteractionConfig.cs
@@ -27,7 +27,7 @@ namespace SecondBotEvents.Config
 
         public bool GetAcceptTeleports()
         {
-            return ReadSettingAsBool("AcceptTeleports", true);
+            return ReadSettingAsBool("AcceptTeleports", false);
         }
 
         public bool GetAcceptGroupInvites()
diff --git a/SecondBotEvents/Config/RlvConfig.cs b/SecondBotEvents/Config/RlvConfig.cs
index a96fefb..14c97b1 100644
--- a/SecondBotEvents/Config/RlvConfig.cs
+++ b/SecondBotEvents/Config/RlvConfig.cs
@@ -11,18 +11,8 @@ namespace SecondBotEvents.Config
         {
             filename = "rlv";
             settings.Add("Enabled");
-            settings.Add("AllowRlvViaIm");
-            settings.Add("AllowRlvViaObjectOwnerSay");
             settings.Add("HideStatusOutput");
         }
-        public bool GetAllowRlvViaIm()
-        {
-            return ReadSettingAsBool("AllowRlvViaIm", false);
-        }
-        public bool GetAllowRlvViaObjectOwnerSay()
-        {
-            return ReadSettingAsBool("AllowRlvViaObjectOwnerSay", false);
-        }
 
         public bool GetEnabled()
         {
diff --git a/SecondBotEvents/EventsSecondBot.cs b/SecondBotEvents/EventsSecondBot.cs
index ce113b8..f08c41b 100644
--- a/SecondBotEvents/EventsSecondBot.cs
+++ b/SecondBotEvents/EventsSecondBot.cs
@@ -39,6 +39,9 @@ namespace SecondBotEvents
         public EventsService EventsService { get { return (EventsService)GetService("EventsService"); } }
         public DialogService DialogService { get { return (DialogService)GetService("DialogService"); } }
 
+        public CurrentOutfitFolder CurrentOutfitFolder {  get { return (CurrentOutfitFolder)GetService("CurrentOutfitFolder"); } }
+        public RLVService RLV { get { return (RLVService)GetService("RLVService"); } }
+
         public CustomCommandsService CustomCommandsService { get { return (CustomCommandsService)GetService("CustomCommandsService"); } }
 
 
@@ -145,6 +148,8 @@ namespace SecondBotEvents
             lastStatus = new Dictionary<string, string>();
             RegisterService("BotClientService", false);
             RegisterService("DataStoreService");
+            RegisterService("RLVService");
+            RegisterService("CurrentOutfitFolder");
             RegisterService("HttpService");
             RegisterService("CommandsService");
             RegisterService("DiscordService");
diff --git a/SecondBotEvents/RLV/RLVAttachmentInfo.cs b/SecondBotEvents/RLV/RLVAttachmentInfo.cs
new file mode 100644
index 0000000..c250a6b
--- /dev/null
+++ b/SecondBotEvents/RLV/RLVAttachmentInfo.cs
@@ -0,0 +1,19 @@
+using OpenMetaverse;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SecondBotEvents.RLV
+{
+    public class AttachmentInfo
+    {
+        public Primitive Prim;
+        public InventoryItem Item;
+        public UUID InventoryID;
+        public UUID PrimID;
+        public bool MarkedAttached;
+        public AttachmentPoint Point => Prim != null ? Prim.PrimData.AttachmentPoint : AttachmentPoint.Default;
+    }
+}
diff --git a/SecondBotEvents/RLV/RLVEventArgs.cs b/SecondBotEvents/RLV/RLVEventArgs.cs
new file mode 100644
index 0000000..92124df
--- /dev/null
+++ b/SecondBotEvents/RLV/RLVEventArgs.cs
@@ -0,0 +1,34 @@
+/**
+ * Radegast Metaverse Client
+ * Copyright(c) 2009-2014, Radegast Development Team
+ * Copyright(c) 2016-2020, Sjofn, LLC
+ * All rights reserved.
+ *  
+ * Radegast is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.If not, see<https://www.gnu.org/licenses/>.
+ */
+
+using System;
+
+namespace SecondBotEvents.RLV
+{
+    public class RLVEventArgs : EventArgs
+    {
+        public RLVRule Rule { set; get; }
+
+        public RLVEventArgs(RLVRule rule)
+        {
+            Rule = rule;
+        }
+    }
+}
\ No newline at end of file
diff --git a/SecondBotEvents/RLV/RLVRule.cs b/SecondBotEvents/RLV/RLVRule.cs
new file mode 100644
index 0000000..3b8907c
--- /dev/null
+++ b/SecondBotEvents/RLV/RLVRule.cs
@@ -0,0 +1,39 @@
+/**
+ * Radegast Metaverse Client
+ * Copyright(c) 2009-2014, Radegast Development Team
+ * Copyright(c) 2016-2020, Sjofn, LLC
+ * All rights reserved.
+ *  
+ * Radegast is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.If not, see<https://www.gnu.org/licenses/>.
+ */
+
+using OpenMetaverse;
+
+namespace SecondBotEvents.RLV
+{
+    public class RLVRule
+    {
+        public string Behaviour { set; get; }
+        public string Option { set; get; }
+        public string Param { set; get; }
+        public UUID Sender { set; get; }
+        public string SenderName { set; get; }
+
+        public override string ToString()
+        {
+            return string.Format("{0}: {1}:{2}={3} [{4}]", SenderName, Behaviour, Option, Param, Sender);
+        }
+    }
+}
+
diff --git a/SecondBotEvents/Services/CurrentOutfitFolder.cs b/SecondBotEvents/Services/CurrentOutfitFolder.cs
new file mode 100644
index 0000000..f2d5879
--- /dev/null
+++ b/SecondBotEvents/Services/CurrentOutfitFolder.cs
@@ -0,0 +1,626 @@
+using OpenMetaverse;
+using SecondBotEvents.Config;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Metadata;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using static SecondBotEvents.Services.RLVService;
+
+
+namespace SecondBotEvents.Services
+{
+    public class CurrentOutfitFolder : BotServices
+    {
+        #region Fields
+        private bool InitiCOF = false;
+        private bool AppearanceSent = false;
+        private bool COFReady = false;
+        private bool InitialUpdateDone = false;
+        public Dictionary<UUID, InventoryItem> Content = new Dictionary<UUID, InventoryItem>();
+        public InventoryFolder COF;
+        protected bool botConnected = false;
+
+        #endregion Fields
+
+        #region Construction and disposal
+        public CurrentOutfitFolder(EventsSecondBot setMaster) : base(setMaster)
+        {
+        }
+
+        public override string Status()
+        {
+            if (botConnected == false)
+            {
+                return "Waiting for bot";
+            }
+            return "Active";
+        }
+
+        public override void Start()
+        {
+            Stop();
+            running = true;
+            master.BotClientNoticeEvent += BotClientRestart;
+            LogFormater.Info("COF inventor [Starting]");
+        }
+
+        public override void Stop()
+        {
+            if (running == true)
+            {
+                LogFormater.Info("COF inventor [Stopping]");
+            }
+            running = false;
+        }
+
+        protected void BotClientRestart(object o, BotClientNotice e)
+        {
+            LogFormater.Info("COF inventory [Attached to new client]");
+            GetClient().Network.LoggedOut += BotLoggedOut;
+            GetClient().Network.SimConnected += BotLoggedIn;
+        }
+
+        protected void BotLoggedOut(object o, LoggedOutEventArgs e)
+        {
+            GetClient().Network.SimConnected += BotLoggedIn;
+            botConnected = false;
+            LogFormater.Info("COF inventory [Logged out]");
+            UnregisterClientEvents();
+        }
+
+        protected void BotLoggedIn(object o, SimConnectedEventArgs e)
+        {
+            GetClient().Network.SimConnected -= BotLoggedIn;
+            LogFormater.Info("COF inventory [starting]");
+            RegisterClientEvents();
+        }
+        #endregion Construction and disposal
+
+        #region Event handling
+        private void RegisterClientEvents()
+        {
+            GetClient().Network.EventQueueRunning += Network_EventQueueRunning;
+            GetClient().Inventory.FolderUpdated += Inventory_FolderUpdated;
+            GetClient().Inventory.ItemReceived += Inventory_ItemReceived;
+            GetClient().Appearance.AppearanceSet += Appearance_AppearanceSet;
+            GetClient().Objects.KillObject += Objects_KillObject;
+        }
+
+        private void UnregisterClientEvents()
+        {
+            GetClient().Network.EventQueueRunning -= Network_EventQueueRunning;
+            GetClient().Inventory.FolderUpdated -= Inventory_FolderUpdated;
+            GetClient().Inventory.ItemReceived -= Inventory_ItemReceived;
+            GetClient().Appearance.AppearanceSet -= Appearance_AppearanceSet;
+            GetClient().Objects.KillObject -= Objects_KillObject;
+            lock (Content) Content.Clear();
+            InitiCOF = false;
+            AppearanceSent = false;
+            COFReady = false;
+            InitialUpdateDone = false;
+        }
+
+        private void Appearance_AppearanceSet(object sender, AppearanceSetEventArgs e)
+        {
+            AppearanceSent = true;
+            if (COFReady)
+            {
+                InitialUpdate();
+            }
+        }
+
+        private void Inventory_ItemReceived(object sender, ItemReceivedEventArgs e)
+        {
+            var links = ContentLinks();
+            bool partOfCOF = links.Any(cofItem => cofItem.AssetUUID == e.Item.UUID);
+
+            if (partOfCOF)
+            {
+                lock (Content)
+                {
+                    Content[e.Item.UUID] = e.Item;
+                }
+            }
+
+            if (Content.Count != links.Count) return;
+            COFReady = true;
+            if (AppearanceSent)
+            {
+                InitialUpdate();
+            }
+            lock (Content)
+            {
+                foreach (var lk in from link in Content.Values
+                                   where link.InventoryType == InventoryType.Wearable
+                                   select (InventoryWearable)link into w
+                                   select links.Find(l => l.AssetUUID == w.UUID))
+                { }
+            }
+        }
+
+        private readonly object FolderSync = new object();
+
+        private void Inventory_FolderUpdated(object sender, FolderUpdatedEventArgs e)
+        {
+            if (COF == null) return;
+
+            if (e.FolderID == COF.UUID && e.Success)
+            {
+                COF = (InventoryFolder)GetClient().Inventory.Store[COF.UUID];
+                lock (FolderSync)
+                {
+                    lock (Content) Content.Clear();
+
+
+                    List<UUID> items = new List<UUID>();
+                    List<UUID> owners = new List<UUID>();
+
+                    foreach (var link in ContentLinks())
+                    {
+                        //if (Client.Inventory.Store.Contains(link.AssetUUID))
+                        //{
+                        //    continue;
+                        //}
+                        items.Add(link.AssetUUID);
+                        owners.Add(GetClient().Self.AgentID);
+                    }
+
+                    if (items.Count > 0)
+                    {
+                        GetClient().Inventory.RequestFetchInventory(items, owners);
+                    }
+                }
+            }
+        }
+
+        private void Objects_KillObject(object sender, KillObjectEventArgs e)
+        {
+            if (GetClient().Network.CurrentSim != e.Simulator) return;
+
+            Primitive prim = null;
+            if (GetClient().Network.CurrentSim.ObjectsPrimitives.TryGetValue(e.ObjectLocalID, out prim))
+            {
+                UUID invItem = GetAttachmentItem(prim);
+                if (invItem != UUID.Zero)
+                {
+                    RemoveLink(invItem);
+                }
+            }
+        }
+
+        private void Network_EventQueueRunning(object sender, EventQueueRunningEventArgs e)
+        {
+            if (e.Simulator == GetClient().Network.CurrentSim && !InitiCOF)
+            {
+                InitiCOF = true;
+                InitCOF();
+            }
+        }
+        #endregion Event handling
+
+        #region Private methods
+
+        private void RequestDescendants(UUID folderID)
+        {
+            GetClient().Inventory.RequestFolderContents(folderID, GetClient().Self.AgentID, true, true, InventorySortOrder.ByDate);
+        }
+
+        private void InitCOF()
+        {
+            var rootContent = GetClient().Inventory.Store.GetContents(GetClient().Inventory.Store.RootFolder.UUID);
+            foreach (var baseItem in rootContent)
+            {
+                if (baseItem is InventoryFolder folder && folder.PreferredType == FolderType.CurrentOutfit)
+                {
+                    COF = folder;
+                    break;
+                }
+            }
+
+            if (COF == null)
+            {
+                CreateCOF();
+            }
+            else
+            {
+                RequestDescendants(COF.UUID);
+            }
+        }
+
+        private void CreateCOF()
+        {
+            UUID cofID = GetClient().Inventory.CreateFolder(GetClient().Inventory.Store.RootFolder.UUID, "Current Outfit", FolderType.CurrentOutfit);
+            if (GetClient().Inventory.Store.Items.ContainsKey(cofID) && GetClient().Inventory.Store.Items[cofID].Data is InventoryFolder folder)
+            {
+                COF = folder;
+                COFReady = true;
+                if (AppearanceSent)
+                {
+                    InitialUpdate();
+                }
+            }
+        }
+
+        private void InitialUpdate()
+        {
+            if (InitialUpdateDone) return;
+            InitialUpdateDone = true;
+            lock (Content)
+            {
+                var myAtt = GetClient().Network.CurrentSim.ObjectsPrimitives.FindAll(p => p.ParentID == GetClient().Self.LocalID);
+
+                foreach (var item in Content.Values
+                             .Where(item => item is InventoryObject || item is InventoryAttachment)
+                             .Where(item => !IsAttached(myAtt, item)))
+                {
+                    GetClient().Appearance.Attach(item, AttachmentPoint.Default, false);
+                }
+            }
+        }
+        #endregion Private methods
+
+        #region Public methods
+        /// <summary>
+        /// Get COF contents
+        /// </summary>
+        /// <returns>List if InventoryItems that can be part of appearance (attachments, wearables)</returns>
+        public List<InventoryItem> ContentLinks()
+        {
+            var ret = new List<InventoryItem>();
+            if (COF == null) return ret;
+
+            GetClient().Inventory.Store.GetContents(COF)
+                .FindAll(b => CanBeWorn(b) && ((InventoryItem)b).AssetType == AssetType.Link)
+                .ForEach(item => ret.Add((InventoryItem)item));
+
+            return ret;
+        }
+
+        /// <summary>
+        /// Get inventory ID of a prim
+        /// </summary>
+        /// <param name="prim">Prim to check</param>
+        /// <returns>Inventory ID of the object. UUID.Zero if not found</returns>
+        public static UUID GetAttachmentItem(Primitive prim)
+        {
+            if (prim.NameValues == null) return UUID.Zero;
+
+            for (var i = 0; i < prim.NameValues.Length; i++)
+            {
+                if (prim.NameValues[i].Name == "AttachItemID")
+                {
+                    return (UUID)prim.NameValues[i].Value.ToString();
+                }
+            }
+            return UUID.Zero;
+        }
+
+        /// <summary>
+        /// Is an inventory item currently attached
+        /// </summary>
+        /// <param name="attachments">List of root prims that are attached to our avatar</param>
+        /// <param name="item">Inventory item to check</param>
+        /// <returns>True if the inventory item is attached to avatar</returns>
+        public static bool IsAttached(List<Primitive> attachments, InventoryItem item)
+        {
+            return attachments.Any(prim => GetAttachmentItem(prim) == item.UUID);
+        }
+
+        /// <summary>
+        /// Checks if inventory item of Wearable type is worn
+        /// </summary>
+        /// <param name="currentlyWorn">Current outfit</param>
+        /// <param name="item">Item to check</param>
+        /// <returns>True if the item is worn</returns>
+        public static bool IsWorn(List<AppearanceManager.WearableData> currentlyWorn, InventoryItem item)
+        {
+            return currentlyWorn.Any(worn => worn.ItemID == item.UUID);
+        }
+
+        /// <summary>
+        /// Can this inventory type be worn
+        /// </summary>
+        /// <param name="item">Item to check</param>
+        /// <returns>True if the inventory item can be worn</returns>
+        public static bool CanBeWorn(InventoryBase item)
+        {
+            return item is InventoryWearable || item is InventoryAttachment || item is InventoryObject;
+        }
+
+        /// <summary>
+        /// Attach an inventory item
+        /// </summary>
+        /// <param name="item">Item to be attached</param>
+        /// <param name="point">Attachment point</param>
+        /// <param name="replace">Replace existing attachment at that point first?</param>
+        public void Attach(InventoryItem item, AttachmentPoint point, bool replace)
+        {
+            GetClient().Appearance.Attach(item, point, replace);
+            AddLink(item);
+        }
+
+        /// <summary>
+        /// Creates a new COF link
+        /// </summary>
+        /// <param name="item">Original item to be linked from COF</param>
+        public void AddLink(InventoryItem item)
+        {
+            if (item.InventoryType == InventoryType.Wearable && !IsBodyPart(item))
+            {
+                var w = (InventoryWearable)item;
+                int layer = 0;
+                string desc = $"@{(int)w.WearableType}{layer:00}";
+                AddLink(item, desc);
+            }
+            else
+            {
+                AddLink(item, string.Empty);
+            }
+        }
+
+        /// <summary>
+        /// Creates a new COF link
+        /// </summary>
+        /// <param name="item">Original item to be linked from COF</param>
+        /// <param name="newDescription">Description for the link</param>
+        public void AddLink(InventoryItem item, string newDescription)
+        {
+            if (COF == null) return;
+
+            bool linkExists = null != ContentLinks().Find(itemLink => itemLink.AssetUUID == item.UUID);
+
+            if (!linkExists)
+            {
+                GetClient().Inventory.CreateLink(COF.UUID, item.UUID, item.Name, newDescription,
+                    AssetType.Link, item.InventoryType, UUID.Random(),
+                    (success, newItem) =>
+                    {
+                        if (success)
+                        {
+                            GetClient().Inventory.RequestFetchInventory(newItem.UUID, newItem.OwnerID);
+                        }
+                    });
+            }
+        }
+
+        /// <summary>
+        /// Remove a link to specified inventory item
+        /// </summary>
+        /// <param name="itemID">ID of the target inventory item for which we want link to be removed</param>
+        public void RemoveLink(UUID itemID)
+        {
+            RemoveLink(new List<UUID>(1) { itemID });
+        }
+
+        /// <summary>
+        /// Remove a link to specified inventory item
+        /// </summary>
+        /// <param name="itemIDs">List of IDs of the target inventory item for which we want link to be removed</param>
+        public void RemoveLink(List<UUID> itemIDs)
+        {
+            if (COF == null) return;
+
+            foreach (var links in itemIDs.Select(itemID => ContentLinks()
+                         .FindAll(itemLink => itemLink.AssetUUID == itemID)))
+            {
+                links.ForEach(item => GetClient().Inventory.RemoveItem(item.UUID));
+            }
+        }
+
+        /// <summary>
+        /// Remove attachment
+        /// </summary>
+        /// <param name="item">>Inventory item to be detached</param>
+        public void Detach(InventoryItem item)
+        {
+            var realItem = RealInventoryItem(item);
+            if (!master.RLV.AllowDetach(realItem)) return;
+
+            GetClient().Appearance.Detach(item);
+            RemoveLink(item.UUID);
+        }
+
+        public List<InventoryItem> GetWornAt(WearableType type)
+        {
+            var ret = new List<InventoryItem>();
+            ContentLinks().ForEach(link =>
+            {
+                var item = RealInventoryItem(link);
+                if (!(item is InventoryWearable wearable)) return;
+
+                if (wearable.WearableType == type)
+                {
+                    ret.Add(wearable);
+                }
+            });
+
+            return ret;
+        }
+
+        /// <summary>
+        /// Resolves inventory links and returns a real inventory item that
+        /// the link is pointing to
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns></returns>
+        public InventoryItem RealInventoryItem(InventoryItem item)
+        {
+            if (item.IsLink() && GetClient().Inventory.Store.Contains(item.AssetUUID)
+                              && GetClient().Inventory.Store[item.AssetUUID] is InventoryItem invItem)
+            {
+                return invItem;
+            }
+
+            return item;
+        }
+
+        /// <summary>
+        /// Replaces the current outfit and updates COF links accordingly
+        /// </summary>
+        /// <param name="newOutfit">List of new wearables and attachments that comprise the new outfit</param>
+        public void ReplaceOutfit(List<InventoryItem> newOutfit)
+        {
+            // Resolve inventory links
+            var outfit = newOutfit.Select(RealInventoryItem).ToList();
+
+            // Remove links to all exiting items
+            var toRemove = new List<UUID>();
+            ContentLinks().ForEach(item =>
+            {
+                if (IsBodyPart(item))
+                {
+                    WearableType linkType = ((InventoryWearable)RealInventoryItem(item)).WearableType;
+                    bool hasBodyPart = newOutfit.Select(RealInventoryItem).Where(IsBodyPart).Any(newItem =>
+                        ((InventoryWearable)newItem).WearableType == linkType);
+
+                    if (hasBodyPart)
+                    {
+                        toRemove.Add(item.UUID);
+                    }
+                }
+                else
+                {
+                    toRemove.Add(item.UUID);
+                }
+            });
+
+            foreach (var item in toRemove)
+            {
+                GetClient().Inventory.RemoveItem(item);
+            }
+
+            // Add links to new items
+            var newItems = outfit.FindAll(CanBeWorn);
+            foreach (var item in newItems)
+            {
+                AddLink(item);
+            }
+
+            GetClient().Appearance.ReplaceOutfit(outfit, false);
+            ThreadPool.QueueUserWorkItem(sync =>
+            {
+                Thread.Sleep(2000);
+                GetClient().Appearance.RequestSetAppearance(true);
+            });
+        }
+
+        /// <summary>
+        /// Add items to current outfit
+        /// </summary>
+        /// <param name="item">Item to add</param>
+        /// <param name="replace">Should existing wearable of the same type be removed</param>
+        public void AddToOutfit(InventoryItem item, bool replace)
+        {
+            AddToOutfit(new List<InventoryItem>(1) { item }, replace);
+        }
+
+        /// <summary>
+        /// Add items to current outfit
+        /// </summary>
+        /// <param name="items">List of items to add</param>
+        /// <param name="replace">Should existing wearable of the same type be removed</param>
+        public void AddToOutfit(List<InventoryItem> items, bool replace)
+        {
+            var current = ContentLinks();
+            var toRemove = new List<UUID>();
+
+            // Resolve inventory links and remove wearables of the same type from COF
+            var outfit = new List<InventoryItem>();
+
+            foreach (var item in items)
+            {
+                var realItem = RealInventoryItem(item);
+                if (replace && realItem is InventoryWearable wearable)
+                {
+                    foreach (var link in current)
+                    {
+                        var currentItem = RealInventoryItem(link);
+                        if (link.AssetUUID == item.UUID)
+                        {
+                            toRemove.Add(link.UUID);
+                        }
+                        else
+                        {
+                            var w = currentItem as InventoryWearable;
+                            if (w?.WearableType == wearable.WearableType)
+                            {
+                                toRemove.Add(link.UUID);
+                            }
+                        }
+                    }
+                }
+
+                outfit.Add(realItem);
+            }
+
+            foreach (var item in toRemove)
+            {
+                GetClient().Inventory.RemoveItem(item);
+            }
+
+            // Add links to new items
+            var newItems = outfit.FindAll(CanBeWorn);
+            foreach (var item in newItems)
+            {
+                AddLink(item);
+            }
+
+            GetClient().Appearance.AddToOutfit(outfit, replace);
+            ThreadPool.QueueUserWorkItem(sync =>
+            {
+                Thread.Sleep(2000);
+                GetClient().Appearance.RequestSetAppearance(true);
+            });
+        }
+
+        /// <summary>
+        /// Remove an item from the current outfit
+        /// </summary>
+        /// <param name="item">Item to remove</param>
+        public void RemoveFromOutfit(InventoryItem item)
+        {
+            RemoveFromOutfit(new List<InventoryItem>(1) { item });
+        }
+
+        /// <summary>
+        /// Remove specified items from the current outfit
+        /// </summary>
+        /// <param name="items">List of items to remove</param>
+        public void RemoveFromOutfit(List<InventoryItem> items)
+        {
+            // Resolve inventory links
+            var outfit = items.Select(RealInventoryItem).Where(realItem => master.RLV.AllowDetach(realItem)).ToList();
+
+            // Remove links to all items that were removed
+            var toRemove = outfit.FindAll(item => CanBeWorn(item) && !IsBodyPart(item)).Select(item => item.UUID).ToList();
+            RemoveLink(toRemove);
+
+            GetClient().Appearance.RemoveFromOutfit(outfit);
+        }
+
+        public bool IsBodyPart(InventoryItem item)
+        {
+            var realItem = RealInventoryItem(item);
+            if (!(realItem is InventoryWearable wearable)) return false;
+
+            var t = wearable.WearableType;
+            return t == WearableType.Shape ||
+                   t == WearableType.Skin ||
+                   t == WearableType.Eyes ||
+                   t == WearableType.Hair;
+        }
+
+        /// <summary>
+        /// Force rebaking textures
+        /// </summary>
+        public void RebakeTextures()
+        {
+            GetClient().Appearance.RequestSetAppearance(true);
+        }
+
+        #endregion Public methods
+    }
+}
diff --git a/SecondBotEvents/Services/HomeboundService.cs b/SecondBotEvents/Services/HomeboundService.cs
index 8d475ee..d73755c 100644
--- a/SecondBotEvents/Services/HomeboundService.cs
+++ b/SecondBotEvents/Services/HomeboundService.cs
@@ -75,7 +75,6 @@ namespace SecondBotEvents.Services
         }
         protected void Tick()
         {
-            long dif = 0;
             if (evacWanted == true)
             {
                 BotAlertMessage(null, new AlertMessageEventArgs("restart", "999", new OpenMetaverse.StructuredData.OSDMap()));
@@ -327,6 +326,12 @@ namespace SecondBotEvents.Services
                 return;
             }
             Stop();
+            if(master.RLV.Enabled == true)
+            {
+                myConfig.setEnabled(false);
+                LogFormater.Info("Homebound Service [Disabled RLV enabled]");
+                return;
+            }
             running = true;
             master.BotClientNoticeEvent += BotClientRestart;
             LogFormater.Info("Homebound Service [Starting]");
diff --git a/SecondBotEvents/Services/RLVService.cs b/SecondBotEvents/Services/RLVService.cs
new file mode 100644
index 0000000..a3a04cf
--- /dev/null
+++ b/SecondBotEvents/Services/RLVService.cs
@@ -0,0 +1,1092 @@
+using OpenMetaverse;
+using SecondBotEvents.Config;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using RestSharp;
+using OpenMetaverse.StructuredData;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Text;
+using System;
+using SecondBotEvents.RLV;
+
+namespace SecondBotEvents.Services
+{
+    public class RLVService : BotServices
+    {
+        protected RlvConfig myConfig;
+        protected bool botConnected = false;
+        protected CurrentOutfitFolder CurrentOutfitFolder = null;
+
+        public RLVService(EventsSecondBot setMaster) : base(setMaster)
+        {
+            myConfig = new RlvConfig(master.fromEnv, master.fromFolder);
+            this.instance = setMaster;
+            if (myConfig.GetEnabled() == false)
+            {
+                return;
+            }
+        }
+        public override string Status()
+        {
+            if (myConfig == null)
+            {
+                return "No Config";
+            }
+            else if (myConfig.GetHideStatusOutput() == true)
+            {
+                return "hidden";
+            }
+            else if (myConfig.GetEnabled() == false)
+            {
+                return "- Not requested -";
+            }
+            else if (botConnected == false)
+            {
+                return "Waiting for bot";
+            }
+            return "Active";
+        }
+
+        protected void BotClientRestart(object o, BotClientNotice e)
+        {
+            LogFormater.Info("RLV service [Attached to new client]");
+            GetClient().Network.LoggedOut += BotLoggedOut;
+            GetClient().Network.SimConnected += BotLoggedIn;
+        }
+
+        protected void BotLoggedOut(object o, LoggedOutEventArgs e)
+        {
+            GetClient().Network.SimConnected += BotLoggedIn;
+            botConnected = false;
+            LogFormater.Info("RLV service [Logged out]");
+            removeEvents();
+        }
+
+        protected void BotLoggedIn(object o, SimConnectedEventArgs e)
+        {
+            GetClient().Network.SimConnected -= BotLoggedIn;
+            GetClient().Self.ChatFromSimulator += BotChatEvents;
+            CurrentOutfitFolder = master.CurrentOutfitFolder;
+            botConnected = true;
+            // attach events
+            RLVWearables = new List<RLVWearable>();
+            RLVAttachments = new List<RLVAttachment>
+            {
+                new RLVAttachment() {Name = "none", Point = AttachmentPoint.Default}
+            };
+            foreach (WearableType wear in Enum.GetValues(typeof(WearableType)))
+            {
+                if (wear.Equals(WearableType.Invalid)) continue;
+                string wearstr = Utils.EnumToText(wear);
+                RLVWearables.Add(new RLVWearable() { Name = wearstr.ToLower(), Type = wear });
+            }
+            foreach (AttachmentPoint pt in Enum.GetValues(typeof(AttachmentPoint)))
+            {
+                string ptstr = Utils.EnumToText(pt);
+                if (pt.Equals(AttachmentPoint.Default) || ptstr.StartsWith("HUD")) continue;
+                RLVAttachments.Add(new RLVAttachment { Name = ptstr.ToLower(), Point = pt });
+            }
+        }
+
+        protected void removeEvents()
+        {
+            botConnected = false;
+            if (GetClient() != null)
+            {
+                // remove events
+                GetClient().Self.ChatFromSimulator -= BotChatEvents;
+            }
+        }
+
+
+        public override void Start()
+        {
+            if (myConfig.GetEnabled() == false)
+            {
+                LogFormater.Info("Events service [Disabled]");
+                return;
+            }
+            Stop();
+            running = true;
+            master.BotClientNoticeEvent += BotClientRestart;
+        }
+
+        public override void Stop()
+        {
+            if (myConfig.GetEnabled() == false)
+            {
+                return;
+            }
+            running = false;
+            master.BotClientNoticeEvent -= BotClientRestart;
+            removeEvents();
+        }
+
+        #region Events
+        /// <summary>The event subscribers. null if no subcribers</summary>
+        private EventHandler<RLVEventArgs> m_RLVRuleChanged;
+
+        /// <summary>Raises the RLVRuleChanged event</summary>
+        /// <param name="e">An RLVRuleChangedEventArgs object containing the
+        /// data returned from the data server</param>
+        protected virtual void OnRLVRuleChanged(RLVEventArgs e)
+        {
+            EventHandler<RLVEventArgs> handler = m_RLVRuleChanged;
+            try
+            {
+                handler?.Invoke(this, e);
+            }
+            catch (Exception) { }
+
+        }
+
+        /// <summary>Thread sync lock object</summary>
+        private readonly object m_RLVRuleChangedLock = new object();
+
+        /// <summary>Triggered when an RLVRuleChangedUpdate packet is received,
+        /// telling us what our avatar is currently wearing
+        /// <see cref="RequestRLVRuleChanged"/> request.</summary>
+        public event EventHandler<RLVEventArgs> RLVRuleChanged
+        {
+            add { lock (m_RLVRuleChangedLock) { m_RLVRuleChanged += value; } }
+            remove { lock (m_RLVRuleChangedLock) { m_RLVRuleChanged -= value; } }
+        }
+        #endregion
+
+        #region Helper classes, methods, structs and enums
+        public struct RLVWearable
+        {
+            public string Name { get; set; }
+            public WearableType Type { get; set; }
+        }
+
+        public struct RLVAttachment
+        {
+            public string Name { get; set; }
+            public AttachmentPoint Point { get; set; }
+        }
+
+        public List<RLVWearable> RLVWearables;
+        public List<RLVAttachment> RLVAttachments;
+
+        public WearableType WearableFromString(string type)
+        {
+            var found = RLVWearables.FindAll(w => w.Name == type);
+            return found.Count == 1 ? found[0].Type : WearableType.Invalid;
+        }
+
+        public AttachmentPoint AttachmentPointFromString(string point)
+        {
+            var found = RLVAttachments.FindAll(a => a.Name == point);
+            return found.Count == 1 ? found[0].Point : AttachmentPoint.Default;
+        }
+
+        #endregion Helper classes, structs and enums
+
+        public bool Enabled
+        {
+            get
+            {
+                return myConfig.GetEnabled();
+            }
+
+            set
+            {
+                myConfig.setEnabled(value);
+                if (value)
+                    StartTimer();
+                else
+                    StopTimer();
+            }
+        }
+
+        GridClient client => instance.BotClient.GetClient();
+        EventsSecondBot instance = null;
+        readonly Regex rlv_regex = new Regex(@"(?<behaviour>[^:=]+)(:(?<option>[^=]*))?=(?<param>\w+)", RegexOptions.Compiled);
+        readonly List<RLVRule> rules = new List<RLVRule>();
+        System.Timers.Timer CleanupTimer;
+
+        void StartTimer()
+        {
+            StopTimer();
+            CleanupTimer = new System.Timers.Timer()
+            {
+                Enabled = true,
+                Interval = 120 * 1000 // two minutes
+            };
+
+            CleanupTimer.Elapsed += CleanupTimer_Elapsed;
+        }
+
+        private void CleanupTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
+        {
+            var objects = new List<UUID>();
+            lock (rules)
+            {
+                foreach (var rule in rules.Where(rule => !objects.Contains(rule.Sender)))
+                {
+                    objects.Add(rule.Sender);
+                }
+            }
+
+            foreach (var obj in objects.Where(obj => client.Network.CurrentSim.ObjectsPrimitives
+                                           .Find(p => p.ID == obj) == null))
+            {
+                Clear(obj);
+            }
+        }
+
+        private void StopTimer()
+        {
+            if (CleanupTimer != null)
+            {
+                CleanupTimer.Enabled = false;
+                CleanupTimer.Dispose();
+                CleanupTimer = null;
+            }
+        }
+
+
+        protected void BotChatEvents(object o, ChatEventArgs e)
+        {
+            if (e.Message.StartsWith("@") == false)
+            {
+                return;
+            }
+            if (e.Type != ChatType.OwnerSay)
+            {
+                return;
+            }
+            TryProcessCMD(e);
+        }
+
+        public bool TryProcessCMD(ChatEventArgs e)
+        {
+            if (!Enabled || !e.Message.StartsWith("@")) return false;
+
+            if (e.Message == "@clear")
+            {
+                Clear(e.SourceID);
+                return true;
+            }
+
+            foreach (var cmd in e.Message.Substring(1).Split(','))
+            {
+                var m = rlv_regex.Match(cmd);
+                if (!m.Success) continue;
+
+                var rule = new RLVRule
+                {
+                    Behaviour = m.Groups["behaviour"].ToString().ToLower(),
+                    Option = m.Groups["option"].ToString(),
+                    Param = m.Groups["param"].ToString().ToLower(),
+                    Sender = e.SourceID,
+                    SenderName = e.FromName
+                };
+
+                Logger.DebugLog(rule.ToString());
+
+                if (rule.Param == "rem") rule.Param = "y";
+                if (rule.Param == "add") rule.Param = "n";
+
+                switch (rule.Param)
+                {
+                    case "n":
+                        lock (rules)
+                        {
+                            var existing = rules.Find(r =>
+                                r.Behaviour == rule.Behaviour &&
+                                r.Sender == rule.Sender &&
+                                r.Option == rule.Option);
+
+                            if (existing != null)
+                            {
+                                rules.Remove(existing);
+                            }
+                            rules.Add(rule);
+                            OnRLVRuleChanged(new RLVEventArgs(rule));
+                        }
+                        continue;
+                    case "y":
+                        lock (rules)
+                        {
+                            if (rule.Option == "")
+                            {
+                                rules.RemoveAll(r => r.Behaviour == rule.Behaviour && r.Sender == rule.Sender);
+                            }
+                            else
+                            {
+                                rules.RemoveAll(r => r.Behaviour == rule.Behaviour && r.Sender == rule.Sender && r.Option == rule.Option);
+                            }
+                        }
+
+                        OnRLVRuleChanged(new RLVEventArgs(rule));
+                        continue;
+                }
+
+
+                switch (rule.Behaviour)
+                {
+                    case "version":
+                        int chan = 0;
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            Respond(chan, "RestrainedLife viewer v1.23 (SecondBot Events)");
+                        }
+                        break;
+
+                    case "versionnew":
+                        chan = 0;
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            Respond(chan, "RestrainedLove viewer v1.23 (SecondBot Events)");
+                        }
+                        break;
+
+
+                    case "versionnum":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            Respond(chan, "1230100");
+                        }
+                        break;
+
+                    case "getgroup":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            UUID gid = client.Self.ActiveGroup;
+                            if (instance.DataStoreService.GetGroups().ContainsKey(gid) == true)
+                            {
+                                Respond(chan, instance.DataStoreService.GetGroups()[gid]);
+                            }
+                        }
+                        break;
+
+                    case "setgroup":
+                        {
+                            if (rule.Param == "force")
+                            {
+                                foreach (var g in instance.DataStoreService.GetGroups())
+                                {
+                                    if (g.Value.ToLower() == rule.Option)
+                                    {
+                                        client.Groups.ActivateGroup(g.Key);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+
+                    case "getpath":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            var attachment = client.Network.CurrentSim.ObjectsPrimitives.Find(p => p.ParentID == client.Self.LocalID && p.ID == rule.Sender);
+                            if (attachment != null && client.Inventory.Store.Items.ContainsKey(CurrentOutfitFolder.GetAttachmentItem(attachment)))
+                            {
+                                var item = client.Inventory.Store.Items[CurrentOutfitFolder.GetAttachmentItem(attachment)];
+                                var path = FindFullInventoryPath(item, "").Substring(5);
+                                Respond(chan, path);
+                            }
+                        }
+                        break;
+
+                    case "getpathnew":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            if (UUID.TryParse(rule.Option, out UUID uuid) && uuid != UUID.Zero)
+                            {
+                                var attachment = client.Network.CurrentSim.ObjectsPrimitives.Find(p => p.ParentID == client.Self.LocalID && p.ID == uuid);
+                                if (attachment != null && client.Inventory.Store.Items.ContainsKey(CurrentOutfitFolder.GetAttachmentItem(attachment)))
+                                {
+                                    var item = client.Inventory.Store.Items[CurrentOutfitFolder.GetAttachmentItem(attachment)];
+                                    var path = FindFullInventoryPath(item, "");
+                                    if (path.StartsWith("#RLV"))
+                                    {
+                                        Respond(chan, "getpathnew: " + path.Substring(5));
+                                    }
+                                    else
+                                    {
+                                        Respond(chan, "getpathnew: ");
+                                    }
+                                }
+                                else
+                                {
+                                    Respond(chan, "getpathnew: ");
+                                }
+                            }
+                        }
+                        break;
+
+                    case "getsitid":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            Avatar me;
+                            if (client.Network.CurrentSim.ObjectsAvatars.TryGetValue(client.Self.LocalID, out me))
+                            {
+                                if (me.ParentID != 0)
+                                {
+                                    Primitive seat;
+                                    if (client.Network.CurrentSim.ObjectsPrimitives.TryGetValue(me.ParentID, out seat))
+                                    {
+                                        Respond(chan, seat.ID.ToString());
+                                        break;
+                                    }
+                                }
+                            }
+                            Respond(chan, UUID.Zero.ToString());
+                        }
+                        break;
+
+                    case "getstatusall":
+                    case "getstatus":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            string sep = "/";
+                            string filter = "";
+
+                            if (!string.IsNullOrEmpty(rule.Option))
+                            {
+                                var parts = rule.Option.Split(';');
+                                if (parts.Length > 1 && parts[1].Length > 0)
+                                {
+                                    sep = parts[1].Substring(0, 1);
+                                }
+                                if (parts.Length > 0 && parts[0].Length > 0)
+                                {
+                                    filter = parts[0].ToLower();
+                                }
+                            }
+
+                            lock (rules)
+                            {
+                                string res = "";
+                                rules
+                                    .FindAll(r => (rule.Behaviour == "getstatusall" || r.Sender == rule.Sender) && r.Behaviour.Contains(filter))
+                                    .ForEach(objRule =>
+                                    {
+                                        res += sep + objRule.Behaviour;
+                                        if (!string.IsNullOrEmpty(objRule.Option))
+                                        {
+                                            res += ":" + objRule.Option;
+                                        }
+                                    });
+                                Respond(chan, res);
+                            }
+                        }
+                        break;
+
+                    case "sit":
+                        UUID sitTarget = UUID.Zero;
+                        if (rule.Param == "force")
+                        {
+                            if (rule.Option != "")
+                            {
+                                UUID.TryParse(rule.Option, out sitTarget);
+                            }
+                            string[] args = { sitTarget.ToString() };
+                            SignedCommand C = new SignedCommand(master.CommandsService, "rlv", "Sit", null, args, 0, "", false, 0, "", false);
+                            master.CommandsService.RunCommand(C);
+                        }
+                        break;
+
+                    case "unsit":
+                        if (rule.Param == "force")
+                        {
+                            // stand
+                            SignedCommand C = new SignedCommand(master.CommandsService, "rlv", "Stand", null, new string[] { }, 0, "", false, 0, "", false);
+                            master.CommandsService.RunCommand(C);
+                        }
+                        break;
+
+                    case "setrot":
+                        double rot = 0.0;
+
+                        if (rule.Param == "force" && double.TryParse(rule.Option, System.Globalization.NumberStyles.Float, Utils.EnUsCulture, out rot))
+                        {
+                            client.Self.Movement.UpdateFromHeading(Math.PI / 2d - rot, true);
+                        }
+                        break;
+
+                    case "tpto":
+                        if (rule.Param == "force")
+                        {
+                            var coord = rule.Option.Split('/', ';');
+                            try
+                            {
+                                if (coord.Length ==
+                                    3) // 3 params is a global coordinate teleport: @tpto:<X>/<Y>/<Z>=force
+                                {
+                                    float gx = float.Parse(coord[0], Utils.EnUsCulture);
+                                    float gy = float.Parse(coord[1], Utils.EnUsCulture);
+                                    float z = float.Parse(coord[2], Utils.EnUsCulture);
+                                    float x = 0, y = 0;
+                                    ulong h = Helpers.GlobalPosToRegionHandle(gx, gy, out x, out y);
+                                    client.Self.RequestTeleport(h, new Vector3(x, y, z));
+                                }
+                                else if (
+                                    coord.Length == 4 ||
+                                    coord.Length ==
+                                    5) // 4/5 params is a region-local coordinate teleport (no ;lookat support): @tpto:<region_name>/<X_local>/<Y_local>/<Z_local>[;lookat]=force
+                                {
+                                    string n = coord[0];
+                                    float x = float.Parse(coord[1], Utils.EnUsCulture);
+                                    float y = float.Parse(coord[2], Utils.EnUsCulture);
+                                    float z = float.Parse(coord[3], Utils.EnUsCulture);
+
+                                    GridRegion r;
+                                    client.Grid.GetGridRegion(n, GridLayerType.Objects, out r);
+                                    client.Self.RequestTeleport(r.RegionHandle, new Vector3(x, y, z));
+                                }
+                            }
+                            catch
+                            {
+                            }
+                        }
+
+                        break;
+
+                    #region #RLV folder and outfit manipulation
+                    case "getoutfit":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            var wearables = client.Appearance.GetWearablesByType();
+                            string res = "";
+
+                            // Do we have a specific wearable to check, ie @getoutfit:socks=99
+                            if (!string.IsNullOrEmpty(rule.Option))
+                            {
+                                res = wearables.ContainsKey(WearableFromString(rule.Option)) ? "1" : "0";
+                            }
+                            else
+                            {
+                                foreach (var t in RLVWearables)
+                                {
+                                    if (wearables.ContainsKey(t.Type))
+                                    {
+                                        res += "1";
+                                    }
+                                    else
+                                    {
+                                        res += "0";
+                                    }
+                                }
+                            }
+                            Respond(chan, res);
+                        }
+                        break;
+
+                    case "getattach":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            string res = "";
+                            var attachments = client.Network.CurrentSim.ObjectsPrimitives.FindAll(p => p.ParentID == client.Self.LocalID);
+                            if (attachments.Count > 0)
+                            {
+                                var myPoints = new List<AttachmentPoint>(attachments.Count);
+                                foreach (var p in attachments)
+                                {
+                                    if (!myPoints.Contains(p.PrimData.AttachmentPoint))
+                                    {
+                                        myPoints.Add(p.PrimData.AttachmentPoint);
+                                    }
+                                }
+
+                                // Do we want to check one single attachment
+                                if (!string.IsNullOrEmpty(rule.Option))
+                                {
+                                    res = myPoints.Contains(AttachmentPointFromString(rule.Option)) ? "1" : "0";
+                                }
+                                else
+                                {
+                                    foreach (var a in RLVAttachments)
+                                    {
+                                        if (myPoints.Contains(a.Point))
+                                        {
+                                            res += "1";
+                                        }
+                                        else
+                                        {
+                                            res += "0";
+                                        }
+                                    }
+                                }
+
+
+                            }
+                            Respond(chan, res);
+                        }
+                        break;
+
+                    case "remattach":
+                    case "detach":
+                        if (rule.Param == "force")
+                        {
+                            if (!string.IsNullOrEmpty(rule.Option))
+                            {
+                                var point = RLVAttachments.Find(a => a.Name == rule.Option);
+                                if (point.Name == rule.Option)
+                                {
+                                    var attachment = client.Network.CurrentSim.ObjectsPrimitives.Find(p => p.ParentID == client.Self.LocalID && p.PrimData.AttachmentPoint == point.Point);
+                                    if (attachment != null && client.Inventory.Store.Items.ContainsKey(CurrentOutfitFolder.GetAttachmentItem(attachment)))
+                                    {
+                                        master.CurrentOutfitFolder.Detach((InventoryItem)client.Inventory.Store.Items[CurrentOutfitFolder.GetAttachmentItem(attachment)].Data);
+                                    }
+                                }
+                                else
+                                {
+                                    InventoryNode folder = FindFolder(rule.Option);
+                                    if (folder != null)
+                                    {
+                                        var outfit = (from item in folder.Nodes.Values where CurrentOutfitFolder.CanBeWorn(item.Data) select (InventoryItem)(item.Data)).ToList();
+                                        master.CurrentOutfitFolder.RemoveFromOutfit(outfit);
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                client.Network.CurrentSim.ObjectsPrimitives.FindAll(p => p.ParentID == client.Self.LocalID).ForEach(attachment =>
+                                {
+                                    if (client.Inventory.Store.Items.ContainsKey(CurrentOutfitFolder.GetAttachmentItem(attachment)))
+                                    {
+                                        master.CurrentOutfitFolder.Detach((InventoryItem)client.Inventory.Store.Items[CurrentOutfitFolder.GetAttachmentItem(attachment)].Data);
+                                    }
+                                });
+                            }
+                        }
+                        break;
+                    case "detachall":
+                        if (rule.Param == "force")
+                        {
+                            if (!string.IsNullOrEmpty(rule.Option))
+                            {
+                                InventoryNode folder = FindFolder(rule.Option);
+                                if (folder != null)
+                                {
+                                    List<InventoryItem> allItems = new List<InventoryItem>();
+                                    AllSubfolderWearables(folder, ref allItems);
+                                    List<InventoryItem> allSubfolderWorn = allItems.Where(n => CurrentOutfitFolder.CanBeWorn(n)).ToList();
+                                    master.CurrentOutfitFolder.RemoveFromOutfit(allSubfolderWorn);
+                                }
+                            }
+                        }
+                        break;
+
+                    case "detachallthis":
+                        if (rule.Param == "force")
+                        {
+                            var attachment = client.Network.CurrentSim.ObjectsPrimitives.Find(p => p.ParentID == client.Self.LocalID && p.ID == rule.Sender);
+                            if (attachment != null && client.Inventory.Store.Items.ContainsKey(CurrentOutfitFolder.GetAttachmentItem(attachment)))
+                            {
+                                var folder = client.Inventory.Store.Items[CurrentOutfitFolder.GetAttachmentItem(attachment)].Parent;
+                                if (folder != null)
+                                {
+                                    List<InventoryItem> outfit = new List<InventoryItem>();
+                                    GetAllItems(folder, true, ref outfit);
+                                    master.CurrentOutfitFolder.RemoveFromOutfit(outfit);
+                                }
+                            }
+                        }
+                        break;
+
+                    case "remoutfit":
+                        if (rule.Param == "force")
+                        {
+                            if (!string.IsNullOrEmpty(rule.Option))
+                            {
+                                var w = RLVWearables.Find(a => a.Name == rule.Option);
+                                if (w.Name == rule.Option)
+                                {
+                                    var items = master.CurrentOutfitFolder.GetWornAt(w.Type);
+                                    master.CurrentOutfitFolder.RemoveFromOutfit(items);
+                                }
+                            }
+                        }
+                        break;
+
+                    case "attach":
+                    case "attachoverorreplace":
+                    case "attachover":
+                    case "attachall":
+                    case "attachallover":
+                        if (rule.Param == "force")
+                        {
+                            if (!string.IsNullOrEmpty(rule.Option))
+                            {
+                                InventoryNode folder = FindFolder(rule.Option);
+                                if (folder != null)
+                                {
+                                    List<InventoryItem> outfit = new List<InventoryItem>();
+                                    if (rule.Behaviour == "attachall" || rule.Behaviour == "attachallover")
+                                    {
+                                        GetAllItems(folder, true, ref outfit);
+                                    }
+                                    else
+                                    {
+                                        GetAllItems(folder, false, ref outfit);
+                                    }
+
+                                    if (rule.Behaviour == "attachover" || rule.Behaviour == "attachallover")
+                                    {
+                                        master.CurrentOutfitFolder.AddToOutfit(outfit, false);
+                                    }
+                                    else
+                                    {
+                                        master.CurrentOutfitFolder.AddToOutfit(outfit, true);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+
+                    case "getinv":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            string res = string.Empty;
+                            InventoryNode folder = FindFolder(rule.Option);
+                            if (folder != null)
+                            {
+                                res = folder.Nodes.Values.Where(
+                                    f => f.Data is InventoryFolder && !f.Data.Name.StartsWith(".")).Aggregate(
+                                        res, (current, f) => current + (f.Data.Name + ","));
+                            }
+
+                            Respond(chan, res.TrimEnd(','));
+                        }
+                        break;
+
+                    case "getinvworn":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            string res = string.Empty;
+                            InventoryNode root = FindFolder(rule.Option);
+                            if (root != null)
+                            {
+                                res += "|" + GetWornIndicator(root) + ",";
+                                res = root.Nodes.Values.Where(
+                                    n => n.Data is InventoryFolder && !n.Data.Name.StartsWith(".")).Aggregate(
+                                        res, (current, n) => current + (n.Data.Name + "|" + GetWornIndicator(n) + ","));
+                            }
+
+                            Respond(chan, res.TrimEnd(','));
+                        }
+                        break;
+
+                    case "findfolder":
+                    case "findfolders":
+                        if (int.TryParse(rule.Param, out chan) && chan > 0)
+                        {
+                            StringBuilder response = new StringBuilder();
+
+                            string[] keywordsArray = rule.Option.Split(new string[] { "&&" }, StringSplitOptions.None);
+                            if (keywordsArray.Any())
+                            {
+                                List<InventoryNode> matching_nodes = FindFoldersKeyword(keywordsArray);
+                                if (matching_nodes.Any())
+                                {
+                                    if (rule.Behaviour == "findfolder")
+                                    {
+                                        InventoryNode bestCandidate = null;
+                                        int bestCandidateSlashCount = -1;
+                                        foreach (var match in matching_nodes)
+                                        {
+                                            string fullPath = FindFullInventoryPath(match, "");
+                                            int numSlashes = fullPath.Count(ch => ch == '/');
+                                            if (bestCandidate == null || numSlashes > bestCandidateSlashCount)
+                                            {
+                                                bestCandidateSlashCount = numSlashes;
+                                                bestCandidate = match;
+                                            }
+                                        }
+
+                                        string bestCandidatePath = bestCandidate.Data.Name;
+                                        if (bestCandidatePath.Substring(0, 5).ToLower() == @"#rlv/")
+                                        {
+                                            bestCandidatePath = bestCandidatePath.Substring(5);
+                                        }
+                                        response.Append(bestCandidatePath);
+                                    }
+                                    else
+                                    {
+                                        foreach (var node in matching_nodes)
+                                        {
+                                            string fullPath = FindFullInventoryPath(node, "");
+                                            if (fullPath.Length > 4 && fullPath.Substring(0, 5).ToLower() == @"#rlv/")
+                                            {
+                                                fullPath = fullPath.Substring(5);
+                                            }
+                                            response.Append(fullPath + ",");
+                                        }
+                                    }
+                                }
+                            }
+
+                            Respond(chan, response.ToString().TrimEnd(','));
+                        }
+                        break;
+
+                        #endregion #RLV folder and outfit manipulation
+
+                }
+            }
+
+            return true;
+        }
+
+        private void GetAllItems(InventoryNode root, bool recursive, ref List<InventoryItem> items)
+        {
+            foreach (var item in root.Nodes.Values)
+            {
+                if (CurrentOutfitFolder.CanBeWorn(item.Data))
+                {
+                    items.Add((InventoryItem)item.Data);
+                }
+                if (recursive)
+                {
+                    foreach (var child in item.Nodes.Values)
+                    {
+                        GetAllItems(child, true, ref items);
+                    }
+                }
+            }
+        }
+
+        private void Respond(int chan, string msg)
+        {
+            client.Self.Chat(msg, chan, ChatType.Normal);
+        }
+
+
+        public void AllSubfolderWearables(InventoryNode root, ref List<InventoryItem> WearableItems)
+        {
+            foreach (var n in root.Nodes.Values)
+            {
+                if (!n.Data.Name.StartsWith("."))
+                {
+                    if (n.Data is InventoryFolder)
+                    {
+                        AllSubfolderWearables(n, ref WearableItems);
+                    }
+                    else
+                    {
+                        WearableItems.Add((InventoryItem)n.Data);
+                    }
+                }
+            }
+
+        }
+
+        protected string GetWornIndicator(InventoryNode node)
+        {
+            var currentOutfit = new List<AppearanceManager.WearableData>(client.Appearance.GetWearables());
+            var currentAttachments =
+                client.Network.CurrentSim.ObjectsPrimitives.FindAll(p => p.ParentID == client.Self.LocalID);
+            int myItemsCount = 0;
+            int myItemsWornCount = 0;
+
+            foreach (var n in node.Nodes.Values)
+            {
+                if (CurrentOutfitFolder.CanBeWorn(n.Data) && !n.Data.Name.StartsWith("."))
+                {
+                    myItemsCount++;
+                    if ((n.Data is InventoryWearable wearable
+                            && CurrentOutfitFolder.IsWorn(currentOutfit, wearable))
+                        || CurrentOutfitFolder.IsAttached(currentAttachments, (InventoryItem)n.Data))
+                    {
+                        myItemsWornCount++;
+                    }
+                }
+            }
+
+            var allItems = new List<InventoryItem>();
+            foreach (var n in node.Nodes.Values)
+            {
+                if (n.Data is InventoryFolder && !n.Data.Name.StartsWith("."))
+                {
+                    AllSubfolderWearables(n, ref allItems);
+                }
+            }
+
+            int allItemsCount = 0;
+            int allItemsWornCount = 0;
+
+            foreach (var n in allItems.Where(n =>
+                CurrentOutfitFolder.CanBeWorn(n) && !n.Name.StartsWith(".")))
+            {
+                allItemsCount++;
+                if ((n is InventoryWearable && CurrentOutfitFolder.IsWorn(currentOutfit, n)) ||
+                    CurrentOutfitFolder.IsAttached(currentAttachments, n))
+                {
+                    allItemsWornCount++;
+                }
+            }
+
+            return WornIndicator(myItemsCount, myItemsWornCount) + WornIndicator(allItemsCount, allItemsWornCount);
+        }
+
+        protected string WornIndicator(int nrMyItem, int nrWorn)
+        {
+            string first = "0";
+
+            if (nrMyItem > 0)
+            {
+                if (nrMyItem == nrWorn)
+                {
+                    first = "3";
+                }
+                else if (nrWorn > 0)
+                {
+                    first = "2";
+                }
+                else
+                {
+                    first = "1";
+                }
+            }
+
+            return first;
+        }
+
+        public InventoryNode RLVRootFolder()
+        {
+            return client.Inventory.Store.RootNode.Nodes.Values.FirstOrDefault(
+                rn => rn.Data.Name == "#RLV" && rn.Data is InventoryFolder);
+        }
+
+        public string FindFullInventoryPath(InventoryNode input, string pathConstruct)
+        {
+            if (input.Parent == null)
+            {
+                return pathConstruct.TrimEnd('/');
+            }
+            else
+            {
+                pathConstruct = input.Data.Name + "/" + pathConstruct;
+                return FindFullInventoryPath(input.Parent, pathConstruct);
+            }
+        }
+
+        public InventoryNode FindFolder(string path)
+        {
+            var root = RLVRootFolder();
+            return root == null ? null : FindFolderInternal(root, "/",
+                "/" + Regex.Replace(path, @"^[/\s]*(.*)[/\s]*", @"$1").ToLower());
+        }
+
+        protected InventoryNode FindFolderInternal(InventoryNode currentNode, string currentPath, string desiredPath)
+        {
+            if (desiredPath == currentPath || desiredPath == (currentPath + "/"))
+            {
+                return currentNode;
+            }
+            return currentNode.Nodes.Values.Select(
+                n => FindFolderInternal(n, (currentPath == "/"
+                    ? currentPath
+                    : currentPath + "/") + n.Data.Name.ToLower(), desiredPath))
+                .FirstOrDefault(res => res != null);
+        }
+
+        public List<InventoryNode> FindFoldersKeyword(string[] keywords)
+        {
+            var matchingNodes = new List<InventoryNode>();
+
+            var root = RLVRootFolder();
+            if (root != null)
+            {
+                FindFoldersKeywordsInternal(root, keywords, new List<string>(), ref matchingNodes);
+            }
+
+            return matchingNodes;
+        }
+
+        protected void FindFoldersKeywordsInternal(InventoryNode currentNode, string[] keywords,
+            List<string> currentPathParts, ref List<InventoryNode> matchingNodes)
+        {
+            if (currentNode.Data is InventoryFolder &&
+                !currentNode.Data.Name.StartsWith(".") &&
+                !currentNode.Data.Name.StartsWith("~") &&
+                keywords.All(currentPathParts.Contains))
+            {
+                matchingNodes.Add(currentNode);
+            }
+
+            foreach (var node in currentNode.Nodes.Values)
+            {
+                if (!(node.Data is InventoryFolder)) continue;
+                currentPathParts.Add(node.Data.Name.ToLower());
+                FindFoldersKeywordsInternal(node, keywords, currentPathParts, ref matchingNodes);
+                currentPathParts.RemoveAt(currentPathParts.Count - 1);
+            }
+        }
+
+        public void Clear(UUID id)
+        {
+            lock (rules)
+            {
+                rules.RemoveAll(r => r.Sender == id);
+            }
+        }
+
+        public bool RestictionActive(string behaviour)
+        {
+            if (!Enabled) return false;
+
+            return rules.FindAll(r => r.Behaviour == behaviour && string.IsNullOrEmpty(r.Option)).Count > 0;
+        }
+
+        public bool RestictionActive(string behaviour, string exception)
+        {
+            if (!Enabled) return false;
+            var set = rules.FindAll(r => r.Behaviour == behaviour);
+
+            return set.Count > 0 &&
+                   set.FindAll(r => r.Option == exception).Count == 0 &&
+                   set.FindAll(r => string.IsNullOrEmpty(r.Option)).Count > 0;
+        }
+
+        public List<string> GetOptions(string behaviour)
+        {
+            List<string> ret = new List<string>();
+
+            foreach (var rule in rules.FindAll(r => r.Behaviour == behaviour && !string.IsNullOrEmpty(r.Option))
+                                      .Where(rule => !ret.Contains(rule.Option)))
+            {
+                ret.Add(rule.Option);
+            }
+
+            return ret;
+        }
+
+        public bool AllowDetach(AttachmentInfo a)
+        {
+            if (!Enabled || a == null) return true;
+
+            return rules.FindAll(r => r.Behaviour == "detach" && r.Sender == a.Prim.ID).Count <= 0;
+        }
+
+        public bool AllowDetach(InventoryItem item)
+        {
+            if (!Enabled || item == null) return true;
+
+            List<Primitive> myAtt =
+                client.Network.CurrentSim.ObjectsPrimitives.FindAll(p => p.ParentID == client.Self.LocalID);
+            foreach (var att in myAtt.Where(att => CurrentOutfitFolder.GetAttachmentItem(att) == item.UUID))
+            {
+                if (rules.FindAll(r => r.Behaviour == "detach" && r.Sender == att.ID).Count > 0)
+                {
+                    return false;
+                }
+                break;
+            }
+            return true;
+        }
+
+        public bool AutoAcceptTP(UUID agent)
+        {
+            if (!Enabled || agent == UUID.Zero) return false;
+
+            return rules.FindAll(r => r.Behaviour == "accepttp" && (r.Option == "" || r.Option == agent.ToString())).Count > 0;
+        }
+    }
+}
+