10 files changed, 969 insertions, 236 deletions

diff --git a/OpenSim/Tools/pCampBot/Behaviours/AbstractBehaviour.cs b/OpenSim/Tools/pCampBot/Behaviours/AbstractBehaviour.cs
index 9a9371d..9bc8512 100644
--- a/OpenSim/Tools/pCampBot/Behaviours/AbstractBehaviour.cs
+++ b/OpenSim/Tools/pCampBot/Behaviours/AbstractBehaviour.cs
@@ -35,6 +35,11 @@ namespace pCampBot
 {
     public class AbstractBehaviour : IBehaviour
     {
+        /// <summary>
+        /// Abbreviated name of this behaviour. 
+        /// </summary>
+        public string AbbreviatedName { get; protected set; }
+
         public string Name { get; protected set; }
 
         public Bot Bot { get; protected set; }
@@ -45,5 +50,7 @@ namespace pCampBot
         {
             Bot = bot;
         }
+
+        public virtual void Close() {}
     }
 }
diff --git a/OpenSim/Tools/pCampBot/Behaviours/CrossBehaviour.cs b/OpenSim/Tools/pCampBot/Behaviours/CrossBehaviour.cs
index 1e01c64..4d806fc 100644
--- a/OpenSim/Tools/pCampBot/Behaviours/CrossBehaviour.cs
+++ b/OpenSim/Tools/pCampBot/Behaviours/CrossBehaviour.cs
@@ -47,7 +47,11 @@ namespace pCampBot
 
         public const int m_regionCrossingTimeout = 1000 * 60;
 
-        public CrossBehaviour() { Name = "Cross"; }
+        public CrossBehaviour() 
+        { 
+            AbbreviatedName = "c";
+            Name = "Cross"; 
+        }
 
         public override void Action()
         {
diff --git a/OpenSim/Tools/pCampBot/Behaviours/GrabbingBehaviour.cs b/OpenSim/Tools/pCampBot/Behaviours/GrabbingBehaviour.cs
index 66a336a..59f6244 100644
--- a/OpenSim/Tools/pCampBot/Behaviours/GrabbingBehaviour.cs
+++ b/OpenSim/Tools/pCampBot/Behaviours/GrabbingBehaviour.cs
@@ -29,6 +29,7 @@ using OpenMetaverse;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using pCampBot.Interfaces;
 
 namespace pCampBot
@@ -41,7 +42,11 @@ namespace pCampBot
     /// </remarks>
     public class GrabbingBehaviour : AbstractBehaviour
     {
-        public GrabbingBehaviour() { Name = "Grabbing"; }
+        public GrabbingBehaviour() 
+        { 
+            AbbreviatedName = "g";
+            Name = "Grabbing"; 
+        }
 
         public override void Action()
         {
@@ -56,6 +61,8 @@ namespace pCampBot
             Bot.Client.Self.Grab(prim.LocalID);
             Bot.Client.Self.GrabUpdate(prim.ID, Vector3.Zero);
             Bot.Client.Self.DeGrab(prim.LocalID);
+
+            Thread.Sleep(1000);
         }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Tools/pCampBot/Behaviours/NoneBehaviour.cs b/OpenSim/Tools/pCampBot/Behaviours/NoneBehaviour.cs
new file mode 100644
index 0000000..9a3075c
--- /dev/null
+++ b/OpenSim/Tools/pCampBot/Behaviours/NoneBehaviour.cs
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using OpenMetaverse;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using pCampBot.Interfaces;
+
+namespace pCampBot
+{
+    /// <summary>
+    /// Do nothing
+    /// </summary>
+    public class NoneBehaviour : AbstractBehaviour
+    {
+        public NoneBehaviour() 
+        { 
+            AbbreviatedName = "n";
+            Name = "None"; 
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Tools/pCampBot/Behaviours/PhysicsBehaviour.cs b/OpenSim/Tools/pCampBot/Behaviours/PhysicsBehaviour.cs
index daa7485..6fd2b7c 100644
--- a/OpenSim/Tools/pCampBot/Behaviours/PhysicsBehaviour.cs
+++ b/OpenSim/Tools/pCampBot/Behaviours/PhysicsBehaviour.cs
@@ -46,6 +46,7 @@ namespace pCampBot
 
         public PhysicsBehaviour()
         {
+            AbbreviatedName = "p";
             Name = "Physics";
             talkarray = readexcuses();
         }
@@ -77,6 +78,12 @@ namespace pCampBot
                 Bot.Client.Self.Chat(randomf, 0, ChatType.Normal);
         }
 
+        public override void Close()
+        {
+            if (Bot.ConnectionState == ConnectionState.Connected)
+                Bot.Client.Self.Jump(false);
+        }
+
         private string[] readexcuses()
         {
             string allexcuses = "";
diff --git a/OpenSim/Tools/pCampBot/Behaviours/TeleportBehaviour.cs b/OpenSim/Tools/pCampBot/Behaviours/TeleportBehaviour.cs
index fbb4e96..81f250d 100644
--- a/OpenSim/Tools/pCampBot/Behaviours/TeleportBehaviour.cs
+++ b/OpenSim/Tools/pCampBot/Behaviours/TeleportBehaviour.cs
@@ -29,6 +29,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Threading;
 using log4net;
 using OpenMetaverse;
 using pCampBot.Interfaces;
@@ -42,7 +43,11 @@ namespace pCampBot
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        public TeleportBehaviour() { Name = "Teleport"; }
+        public TeleportBehaviour() 
+        {
+            AbbreviatedName = "t";
+            Name = "Teleport"; 
+        }
 
         public override void Action()
         {
@@ -70,6 +75,8 @@ namespace pCampBot
                 Bot.Name, sourceRegion.Name, Bot.Client.Self.SimPosition, destRegion.Name, destPosition);
 
             Bot.Client.Self.Teleport(destRegion.RegionHandle, destPosition);
+
+            Thread.Sleep(Bot.Random.Next(3000, 10000));
         }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Tools/pCampBot/Bot.cs b/OpenSim/Tools/pCampBot/Bot.cs
index 9821180..d0a4ef3 100644
--- a/OpenSim/Tools/pCampBot/Bot.cs
+++ b/OpenSim/Tools/pCampBot/Bot.cs
@@ -59,22 +59,23 @@ namespace pCampBot
         public delegate void AnEvent(Bot callbot, EventType someevent); // event delegate for bot events
 
         /// <summary>
-        /// Bot manager.
+        /// Controls whether bots request textures for the object information they receive
         /// </summary>
-        public BotManager Manager { get; private set; }
+        public bool RequestObjectTextures { get; set; }
 
         /// <summary>
-        /// Bot config, passed from BotManager.
+        /// Bot manager.
         /// </summary>
-        private IConfig startupConfig;
+        public BotManager Manager { get; private set; }
 
         /// <summary>
         /// Behaviours implemented by this bot.
         /// </summary>
         /// <remarks>
-        /// Lock this list before manipulating it.
+        /// Indexed by abbreviated name.  There can only be one instance of a particular behaviour.
+        /// Lock this structure before manipulating it.
         /// </remarks>
-        public List<IBehaviour> Behaviours { get; private set; }
+        public Dictionary<string, IBehaviour> Behaviours { get; private set; }
 
         /// <summary>
         /// Objects that the bot has discovered.
@@ -97,11 +98,35 @@ namespace pCampBot
         /// </summary>
         public ConnectionState ConnectionState { get; private set; }
 
+        public List<Simulator> Simulators
+        {
+            get
+            {
+                lock (Client.Network.Simulators)
+                    return new List<Simulator>(Client.Network.Simulators);
+            }
+        }
+
+        /// <summary>
+        /// The number of connections that this bot has to different simulators.
+        /// </summary>
+        /// <value>Includes both root and child connections.</value>
+        public int SimulatorsCount
+        {
+            get
+            {
+                lock (Client.Network.Simulators)
+                    return Client.Network.Simulators.Count;
+            }
+        }
+
         public string FirstName { get; private set; }
         public string LastName { get; private set; }
         public string Name { get; private set; }
         public string Password { get; private set; }
         public string LoginUri { get; private set; }
+        public string StartLocation { get; private set; }
+
         public string saveDir;
         public string wear;
 
@@ -137,94 +162,177 @@ namespace pCampBot
         /// <param name="behaviours"></param>
         public Bot(
             BotManager bm, List<IBehaviour> behaviours,
-            string firstName, string lastName, string password, string loginUri)
+            string firstName, string lastName, string password, string startLocation, string loginUri)
         {
             ConnectionState = ConnectionState.Disconnected;
 
-            behaviours.ForEach(b => b.Initialize(this));
-            
-            Client = new GridClient();
-
             Random = new Random(Environment.TickCount);// We do stuff randomly here
             FirstName = firstName;
             LastName = lastName;
             Name = string.Format("{0} {1}", FirstName, LastName);
             Password = password;
             LoginUri = loginUri;
+            StartLocation = startLocation;
 
             Manager = bm;
-            startupConfig = bm.Config;
-            readconfig();
 
-            Behaviours = behaviours;
+            Behaviours = new Dictionary<string, IBehaviour>();
+            foreach (IBehaviour behaviour in behaviours)
+                AddBehaviour(behaviour);
+
+            // Only calling for use as a template.
+            CreateLibOmvClient();
+        }
+
+        public bool TryGetBehaviour(string abbreviatedName, out IBehaviour behaviour)
+        {
+            lock (Behaviours)
+                return Behaviours.TryGetValue(abbreviatedName, out behaviour);
+        }
+
+        public bool AddBehaviour(IBehaviour behaviour)
+        {
+            lock (Behaviours)
+            {
+                if (!Behaviours.ContainsKey(behaviour.AbbreviatedName))
+                {                    
+                    behaviour.Initialize(this);
+                    Behaviours.Add(behaviour.AbbreviatedName, behaviour);
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public bool RemoveBehaviour(string abbreviatedName)
+        {
+            lock (Behaviours)
+            {
+                IBehaviour behaviour;
+
+                if (!Behaviours.TryGetValue(abbreviatedName, out behaviour))
+                    return false;
+
+                behaviour.Close();
+                Behaviours.Remove(abbreviatedName);
+
+                return true;
+            }
+        }
+
+        private void CreateLibOmvClient()
+        {
+            GridClient newClient = new GridClient();
+
+            if (Client != null)
+            {
+                newClient.Settings.LOGIN_SERVER = Client.Settings.LOGIN_SERVER;
+                newClient.Settings.ALWAYS_DECODE_OBJECTS = Client.Settings.ALWAYS_DECODE_OBJECTS;
+                newClient.Settings.AVATAR_TRACKING = Client.Settings.AVATAR_TRACKING;
+                newClient.Settings.OBJECT_TRACKING = Client.Settings.OBJECT_TRACKING;
+                newClient.Settings.SEND_AGENT_THROTTLE = Client.Settings.SEND_AGENT_THROTTLE;
+                newClient.Settings.SEND_AGENT_UPDATES = Client.Settings.SEND_AGENT_UPDATES;
+                newClient.Settings.SEND_PINGS = Client.Settings.SEND_PINGS;
+                newClient.Settings.STORE_LAND_PATCHES = Client.Settings.STORE_LAND_PATCHES;
+                newClient.Settings.USE_ASSET_CACHE = Client.Settings.USE_ASSET_CACHE;
+                newClient.Settings.MULTIPLE_SIMS = Client.Settings.MULTIPLE_SIMS;
+                newClient.Throttle.Asset = Client.Throttle.Asset;
+                newClient.Throttle.Land = Client.Throttle.Land;
+                newClient.Throttle.Task = Client.Throttle.Task;
+                newClient.Throttle.Texture = Client.Throttle.Texture;
+                newClient.Throttle.Wind = Client.Throttle.Wind;
+                newClient.Throttle.Total = Client.Throttle.Total;
+            }
+            else
+            {
+                newClient.Settings.LOGIN_SERVER = LoginUri;
+                newClient.Settings.ALWAYS_DECODE_OBJECTS = false;
+                newClient.Settings.AVATAR_TRACKING = false;
+                newClient.Settings.OBJECT_TRACKING = false;
+                newClient.Settings.SEND_AGENT_THROTTLE = true;
+                newClient.Settings.SEND_PINGS = true;
+                newClient.Settings.STORE_LAND_PATCHES = false;
+                newClient.Settings.USE_ASSET_CACHE = false;
+                newClient.Settings.MULTIPLE_SIMS = true;
+                newClient.Throttle.Asset = 100000;
+                newClient.Throttle.Land = 100000;
+                newClient.Throttle.Task = 100000;
+                newClient.Throttle.Texture = 100000;
+                newClient.Throttle.Wind = 100000;
+                newClient.Throttle.Total = 400000;
+            }
+
+            newClient.Network.LoginProgress += this.Network_LoginProgress;
+            newClient.Network.SimConnected += this.Network_SimConnected;
+            newClient.Network.Disconnected += this.Network_OnDisconnected;
+            newClient.Objects.ObjectUpdate += Objects_NewPrim;
+
+            Client = newClient;
         }
 
         //We do our actions here.  This is where one would
         //add additional steps and/or things the bot should do
         private void Action()
         {
-            while (true)
+            while (ConnectionState != ConnectionState.Disconnecting)
+            {
                 lock (Behaviours)
-                    Behaviours.ForEach(
-                        b =>
-                        {
-                            Thread.Sleep(Random.Next(3000, 10000));
-                        
-                            // m_log.DebugFormat("[pCAMPBOT]: For {0} performing action {1}", Name, b.GetType());
-                            b.Action();
-                        }
-                    );
-        }
+                {
+                    foreach (IBehaviour behaviour in Behaviours.Values)
+                    {
+//                        Thread.Sleep(Random.Next(3000, 10000));
+                    
+                        // m_log.DebugFormat("[pCAMPBOT]: For {0} performing action {1}", Name, b.GetType());
+                        behaviour.Action();
+                    }
+                }
 
-        /// <summary>
-        /// Read the Nini config and initialize
-        /// </summary>
-        public void readconfig()
-        {
-            wear = startupConfig.GetString("wear", "no");
+                // XXX: This is a really shitty way of yielding so that behaviours can be added/removed
+                Thread.Sleep(100);
+            }
+
+            lock (Behaviours)
+                foreach (IBehaviour b in Behaviours.Values)
+                    b.Close();
         }
 
         /// <summary>
         /// Tells LibSecondLife to logout and disconnect.  Raises the disconnect events once it finishes.
         /// </summary>
-        public void shutdown()
+        public void Disconnect()
         {
             ConnectionState = ConnectionState.Disconnecting;
 
-            if (m_actionThread != null)
-                m_actionThread.Abort();
+//            if (m_actionThread != null)
+//                m_actionThread.Abort();
 
             Client.Network.Logout();
         }
 
+        public void Connect()
+        {            
+            Thread connectThread = new Thread(ConnectInternal);
+            connectThread.Name = Name;
+            connectThread.IsBackground = true;
+
+            connectThread.Start();
+        }
+
         /// <summary>
         /// This is the bot startup loop.
         /// </summary>
-        public void startup()
+        private void ConnectInternal()
         {
-            Client.Settings.LOGIN_SERVER = LoginUri;
-            Client.Settings.ALWAYS_DECODE_OBJECTS = false;
-            Client.Settings.AVATAR_TRACKING = false;
-            Client.Settings.OBJECT_TRACKING = false;
-            Client.Settings.SEND_AGENT_THROTTLE = true;
-            Client.Settings.SEND_PINGS = true;
-            Client.Settings.STORE_LAND_PATCHES = false;
-            Client.Settings.USE_ASSET_CACHE = false;
-            Client.Settings.MULTIPLE_SIMS = true;
-            Client.Throttle.Asset = 100000;
-            Client.Throttle.Land = 100000;
-            Client.Throttle.Task = 100000;
-            Client.Throttle.Texture = 100000;
-            Client.Throttle.Wind = 100000;
-            Client.Throttle.Total = 400000;
-            Client.Network.LoginProgress += this.Network_LoginProgress;
-            Client.Network.SimConnected += this.Network_SimConnected;
-            Client.Network.Disconnected += this.Network_OnDisconnected;
-            Client.Objects.ObjectUpdate += Objects_NewPrim;
-
             ConnectionState = ConnectionState.Connecting;
 
-            if (Client.Network.Login(FirstName, LastName, Password, "pCampBot", "Your name"))
+            // Current create a new client on each connect.  libomv doesn't seem to process new sim
+            // information (e.g. EstablishAgentCommunication events) if connecting after a disceonnect with the same
+            // client
+            CreateLibOmvClient();
+
+            if (Client.Network.Login(FirstName, LastName, Password, "pCampBot", StartLocation, "Your name"))
             {
                 ConnectionState = ConnectionState.Connected;
 
@@ -268,6 +376,30 @@ namespace pCampBot
             }
         }
 
+        /// <summary>
+        /// Sit this bot on the ground.
+        /// </summary>
+        public void SitOnGround()
+        {
+            if (ConnectionState == ConnectionState.Connected)
+                Client.Self.SitOnGround();
+        }
+
+        /// <summary>
+        /// Stand this bot
+        /// </summary>
+        public void Stand()
+        {
+            if (ConnectionState == ConnectionState.Connected)
+            {
+                // Unlike sit on ground, here libomv checks whether we have SEND_AGENT_UPDATES enabled.
+                bool prevUpdatesSetting = Client.Settings.SEND_AGENT_UPDATES;
+                Client.Settings.SEND_AGENT_UPDATES = true;
+                Client.Self.Stand();
+                Client.Settings.SEND_AGENT_UPDATES = prevUpdatesSetting;
+            }
+        }
+
         public void SaveDefaultAppearance()
         {
             saveDir = "MyAppearance/" + FirstName + "_" + LastName;
@@ -468,6 +600,8 @@ namespace pCampBot
 //                    || args.Reason == NetworkManager.DisconnectType.NetworkTimeout)
 //               && OnDisconnected != null)
 
+
+
            if (
                (args.Reason == NetworkManager.DisconnectType.ClientInitiated
                     || args.Reason == NetworkManager.DisconnectType.ServerInitiated
@@ -481,8 +615,8 @@ namespace pCampBot
 
         public void Objects_NewPrim(object sender, PrimEventArgs args)
         {
-//            if (Name.EndsWith("4"))
-//                throw new Exception("Aaargh");
+            if (!RequestObjectTextures)
+                return;
 
             Primitive prim = args.Prim;
 
diff --git a/OpenSim/Tools/pCampBot/BotManager.cs b/OpenSim/Tools/pCampBot/BotManager.cs
index d615b3f..3c1b11e 100644
--- a/OpenSim/Tools/pCampBot/BotManager.cs
+++ b/OpenSim/Tools/pCampBot/BotManager.cs
@@ -52,6 +52,16 @@ namespace pCampBot
         public const int DefaultLoginDelay = 5000;
 
         /// <summary>
+        /// Is pCampbot in the process of connecting bots?
+        /// </summary>
+        public bool ConnectingBots { get; private set; }
+
+        /// <summary>
+        /// Is pCampbot in the process of disconnecting bots?
+        /// </summary>
+        public bool DisconnectingBots { get; private set; }
+
+        /// <summary>
         /// Delay between logins of multiple bots.
         /// </summary>
         /// <remarks>TODO: This value needs to be configurable by a command line argument.</remarks>
@@ -63,19 +73,24 @@ namespace pCampBot
         protected CommandConsole m_console;
 
         /// <summary>
-        /// Created bots, whether active or inactive.
+        /// Controls whether bots start out sending agent updates on connection.
         /// </summary>
-        protected List<Bot> m_lBot;
+        public bool InitBotSendAgentUpdates { get; set; }
 
         /// <summary>
-        /// Random number generator.
+        /// Controls whether bots request textures for the object information they receive
         /// </summary>
-        public Random Rng { get; private set; }
+        public bool InitBotRequestObjectTextures { get; set; }
 
         /// <summary>
-        /// Overall configuration.
+        /// Created bots, whether active or inactive.
         /// </summary>
-        public IConfig Config { get; private set; }
+        protected List<Bot> m_bots;
+
+        /// <summary>
+        /// Random number generator.
+        /// </summary>
+        public Random Rng { get; private set; }
 
         /// <summary>
         /// Track the assets we have and have not received so we don't endlessly repeat requests.
@@ -88,10 +103,53 @@ namespace pCampBot
         public Dictionary<ulong, GridRegion> RegionsKnown { get; private set; }
 
         /// <summary>
+        /// First name for bots
+        /// </summary>
+        private string m_firstName;
+
+        /// <summary>
+        /// Last name stem for bots
+        /// </summary>
+        private string m_lastNameStem;
+
+        /// <summary>
+        /// Password for bots
+        /// </summary>
+        private string m_password;
+
+        /// <summary>
+        /// Login URI for bots.
+        /// </summary>
+        private string m_loginUri;
+
+        /// <summary>
+        /// Start location for bots.
+        /// </summary>
+        private string m_startUri;
+
+        /// <summary>
+        /// Postfix bot number at which bot sequence starts.
+        /// </summary>
+        private int m_fromBotNumber;
+
+        /// <summary>
+        /// Wear setting for bots.
+        /// </summary>
+        private string m_wearSetting;
+
+        /// <summary>
+        /// Behaviour switches for bots.
+        /// </summary>
+        private HashSet<string> m_defaultBehaviourSwitches = new HashSet<string>();
+
+        /// <summary>
         /// Constructor Creates MainConsole.Instance to take commands and provide the place to write data
         /// </summary>
         public BotManager()
         {
+            InitBotSendAgentUpdates = true;
+            InitBotRequestObjectTextures = true;
+
             LoginDelay = DefaultLoginDelay;
 
             Rng = new Random(Environment.TickCount);
@@ -117,30 +175,61 @@ namespace pCampBot
                 }
             }
 
-            m_console.Commands.AddCommand("bot", false, "shutdown",
-                    "shutdown",
-                    "Shutdown bots and exit", HandleShutdown);
-
-            m_console.Commands.AddCommand("bot", false, "quit",
-                    "quit",
-                    "Shutdown bots and exit",
-                    HandleShutdown);
-
-            m_console.Commands.AddCommand("bot", false, "show regions",
-                    "show regions",
-                    "Show regions known to bots",
-                    HandleShowRegions);
-
-            m_console.Commands.AddCommand("bot", false, "show bots",
-                    "show bots",
-                    "Shows the status of all bots",
-                    HandleShowStatus);
-
-//            m_console.Commands.AddCommand("bot", false, "add bots",
-//                    "add bots <number>",
-//                    "Add more bots", HandleAddBots);
-
-            m_lBot = new List<Bot>();
+            m_console.Commands.AddCommand(
+                "bot", false, "shutdown", "shutdown", "Shutdown bots and exit", HandleShutdown);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "quit", "quit", "Shutdown bots and exit", HandleShutdown);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "connect", "connect [<n>]", "Connect bots",
+                "If an <n> is given, then the first <n> disconnected bots by postfix number are connected.\n"
+                    + "If no <n> is given, then all currently disconnected bots are connected.",
+                HandleConnect);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "disconnect", "disconnect [<n>]", "Disconnect bots",
+                "Disconnecting bots will interupt any bot connection process, including connection on startup.\n"
+                    + "If an <n> is given, then the last <n> connected bots by postfix number are disconnected.\n"
+                    + "If no <n> is given, then all currently connected bots are disconnected.",
+                HandleDisconnect);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "add behaviour", "add behaviour <abbreviated-name> [<bot-number>]", 
+                "Add a behaviour to a bot",
+                "If no bot number is specified then behaviour is added to all bots.\n"
+                    + "Can be performed on connected or disconnected bots.",
+                HandleAddBehaviour);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "remove behaviour", "remove behaviour <abbreviated-name> [<bot-number>]", 
+                "Remove a behaviour from a bot",
+                "If no bot number is specified then behaviour is added to all bots.\n"
+                    + "Can be performed on connected or disconnected bots.",
+                HandleRemoveBehaviour);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "sit", "sit", "Sit all bots on the ground.",
+                HandleSit);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "stand", "stand", "Stand all bots.",
+                HandleStand);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "set bots", "set bots <key> <value>", "Set a setting for all bots.", HandleSetBots);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "show regions", "show regions", "Show regions known to bots", HandleShowRegions);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "show bots", "show bots", "Shows the status of all bots", HandleShowBotsStatus);
+
+            m_console.Commands.AddCommand(
+                "bot", false, "show bot", "show bot <bot-number>", 
+                "Shows the detailed status and settings of a particular bot.", HandleShowBotStatus);
+
+            m_bots = new List<Bot>();
         }
 
         /// <summary>
@@ -148,74 +237,167 @@ namespace pCampBot
         /// </summary>
         /// <param name="botcount">How many bots to start up</param>
         /// <param name="cs">The configuration for the bots to use</param>
-        public void dobotStartup(int botcount, IConfig cs)
+        public void CreateBots(int botcount, IConfig startupConfig)
         {
-            Config = cs;
+            m_firstName = startupConfig.GetString("firstname");
+            m_lastNameStem = startupConfig.GetString("lastname");
+            m_password = startupConfig.GetString("password");
+            m_loginUri = startupConfig.GetString("loginuri");
+            m_fromBotNumber = startupConfig.GetInt("from", 0);
+            m_wearSetting = startupConfig.GetString("wear", "no");
 
-            string firstName = cs.GetString("firstname");
-            string lastNameStem = cs.GetString("lastname");
-            string password = cs.GetString("password");
-            string loginUri = cs.GetString("loginuri");
+            m_startUri = ParseInputStartLocationToUri(startupConfig.GetString("start", "last"));
 
-            HashSet<string> behaviourSwitches = new HashSet<string>();
             Array.ForEach<string>(
-                cs.GetString("behaviours", "p").Split(new char[] { ',' }), b => behaviourSwitches.Add(b));
+                startupConfig.GetString("behaviours", "p").Split(new char[] { ',' }), b => m_defaultBehaviourSwitches.Add(b));
+
+            for (int i = 0; i < botcount; i++)
+            {
+                lock (m_bots)
+                {
+                    string lastName = string.Format("{0}_{1}", m_lastNameStem, i + m_fromBotNumber);
+
+                    CreateBot(
+                        this,
+                        CreateBehavioursFromAbbreviatedNames(m_defaultBehaviourSwitches),
+                        m_firstName, lastName, m_password, m_loginUri, m_startUri, m_wearSetting);
+                }
+            }
+        }
+
+        private List<IBehaviour> CreateBehavioursFromAbbreviatedNames(HashSet<string> abbreviatedNames)
+        {
+            // We must give each bot its own list of instantiated behaviours since they store state.
+            List<IBehaviour> behaviours = new List<IBehaviour>();
+
+            // Hard-coded for now    
+            foreach (string abName in abbreviatedNames)
+            {
+                IBehaviour newBehaviour = null;
+
+                if (abName == "c")
+                    newBehaviour = new CrossBehaviour();
+
+                if (abName == "g")
+                    newBehaviour = new GrabbingBehaviour();
+
+                if (abName == "n")
+                    newBehaviour = new NoneBehaviour();
+
+                if (abName == "p")
+                    newBehaviour = new PhysicsBehaviour();
+
+                if (abName == "t")
+                    newBehaviour = new TeleportBehaviour();
+
+                if (newBehaviour != null)
+                {
+                    behaviours.Add(newBehaviour);
+                }
+                else
+                {
+                    MainConsole.Instance.OutputFormat("No behaviour with abbreviated name {0} found", abName);
+                }
+            }
+
+            return behaviours;
+        }
 
+        public void ConnectBots(int botcount)
+        {
+            ConnectingBots = true;
+
+            Thread connectBotThread = new Thread(o => ConnectBotsInternal(botcount));
+
+            connectBotThread.Name = "Bots connection thread";
+            connectBotThread.Start();
+        }
+
+        private void ConnectBotsInternal(int botCount)
+        {
             MainConsole.Instance.OutputFormat(
-                "[BOT MANAGER]: Starting {0} bots connecting to {1}, named {2} {3}_<n>",
-                botcount,
-                loginUri,
-                firstName,
-                lastNameStem);
+                "[BOT MANAGER]: Starting {0} bots connecting to {1}, location {2}, named {3} {4}_<n>",
+                botCount,
+                m_loginUri,
+                m_startUri,
+                m_firstName,
+                m_lastNameStem);
 
             MainConsole.Instance.OutputFormat("[BOT MANAGER]: Delay between logins is {0}ms", LoginDelay);
+            MainConsole.Instance.OutputFormat("[BOT MANAGER]: BotsSendAgentUpdates is {0}", InitBotSendAgentUpdates);
+            MainConsole.Instance.OutputFormat("[BOT MANAGER]: InitBotRequestObjectTextures is {0}", InitBotRequestObjectTextures);
 
-            for (int i = 0; i < botcount; i++)
+            int connectedBots = 0;
+
+            for (int i = 0; i < m_bots.Count; i++)
             {
-                string lastName = string.Format("{0}_{1}", lastNameStem, i);
-
-                // We must give each bot its own list of instantiated behaviours since they store state.
-                List<IBehaviour> behaviours = new List<IBehaviour>();
-    
-                // Hard-coded for now
-                if (behaviourSwitches.Contains("p"))
-                    behaviours.Add(new PhysicsBehaviour());
-    
-                if (behaviourSwitches.Contains("g"))
-                    behaviours.Add(new GrabbingBehaviour());
-    
-                if (behaviourSwitches.Contains("t"))
-                    behaviours.Add(new TeleportBehaviour());
-    
-                if (behaviourSwitches.Contains("c"))
-                    behaviours.Add(new CrossBehaviour());
-
-                StartBot(this, behaviours, firstName, lastName, password, loginUri);
+                lock (m_bots)
+                {
+                    if (DisconnectingBots)
+                    {
+                        MainConsole.Instance.Output(
+                            "[BOT MANAGER]: Aborting bot connection due to user-initiated disconnection");
+                        break;
+                    }
+
+                    if (m_bots[i].ConnectionState == ConnectionState.Disconnected)
+                    {
+                        m_bots[i].Connect();
+                        connectedBots++;
+
+                        if (connectedBots >= botCount)
+                            break;
+
+                        // Stagger logins
+                        Thread.Sleep(LoginDelay);
+                    }
+                }
             }
+
+            ConnectingBots = false;
         }
 
-//        /// <summary>
-//        /// Add additional bots (and threads) to our bot pool
-//        /// </summary>
-//        /// <param name="botcount">How Many of them to add</param>
-//        public void addbots(int botcount)
-//        {
-//            int len = m_td.Length;
-//            Thread[] m_td2 = new Thread[len + botcount];
-//            for (int i = 0; i < len; i++)
-//            {
-//                m_td2[i] = m_td[i];
-//            }
-//            m_td = m_td2;
-//            int newlen = len + botcount;
-//            for (int i = len; i < newlen; i++)
-//            {
-//                startupBot(Config);
-//            }
-//        }
+        /// <summary>
+        /// Parses the command line start location to a start string/uri that the login mechanism will recognize.
+        /// </summary>
+        /// <returns>
+        /// The input start location to URI.
+        /// </returns>
+        /// <param name='startLocation'>
+        /// Start location.
+        /// </param>
+        private string ParseInputStartLocationToUri(string startLocation)
+        {
+            if (startLocation == "home" || startLocation == "last")
+                return startLocation;
+
+            string regionName;
+
+            // Just a region name or only one (!) extra component.  Like a viewer, we will stick 128/128/0 on the end
+            Vector3 startPos = new Vector3(128, 128, 0);
+
+            string[] startLocationComponents = startLocation.Split('/');
+
+            regionName = startLocationComponents[0];
+
+            if (startLocationComponents.Length >= 2)
+            {
+                float.TryParse(startLocationComponents[1], out startPos.X);
+
+                if (startLocationComponents.Length >= 3)
+                {
+                    float.TryParse(startLocationComponents[2], out startPos.Y);
+
+                    if (startLocationComponents.Length >= 4)
+                        float.TryParse(startLocationComponents[3], out startPos.Z);
+                }
+            }
+
+            return string.Format("uri:{0}&{1}&{2}&{3}", regionName, startPos.X, startPos.Y, startPos.Z);
+        }
 
         /// <summary>
-        /// This starts up the bot and stores the thread for the bot in the thread array
+        /// This creates a bot but does not start it.
         /// </summary>
         /// <param name="bm"></param>
         /// <param name="behaviours">Behaviours for this bot to perform.</param>
@@ -223,30 +405,25 @@ namespace pCampBot
         /// <param name="lastName">Last name</param>
         /// <param name="password">Password</param>
         /// <param name="loginUri">Login URI</param>
-        public void StartBot(
+        /// <param name="startLocation">Location to start the bot.  Can be "last", "home" or a specific sim name.</param>
+        /// <param name="wearSetting"></param>
+        public void CreateBot(
              BotManager bm, List<IBehaviour> behaviours,
-             string firstName, string lastName, string password, string loginUri)
+             string firstName, string lastName, string password, string loginUri, string startLocation, string wearSetting)
         {
             MainConsole.Instance.OutputFormat(
-                "[BOT MANAGER]: Starting bot {0} {1}, behaviours are {2}",
+                "[BOT MANAGER]: Creating bot {0} {1}, behaviours are {2}",
                 firstName, lastName, string.Join(",", behaviours.ConvertAll<string>(b => b.Name).ToArray()));
 
-            Bot pb = new Bot(bm, behaviours, firstName, lastName, password, loginUri);
+            Bot pb = new Bot(bm, behaviours, firstName, lastName, password, startLocation, loginUri);
+            pb.wear = wearSetting;
+            pb.Client.Settings.SEND_AGENT_UPDATES = InitBotSendAgentUpdates;
+            pb.RequestObjectTextures = InitBotRequestObjectTextures;
 
             pb.OnConnected += handlebotEvent;
             pb.OnDisconnected += handlebotEvent;
 
-            lock (m_lBot)
-                m_lBot.Add(pb);
-
-            Thread pbThread = new Thread(pb.startup);
-            pbThread.Name = pb.Name;
-            pbThread.IsBackground = true;
-
-            pbThread.Start();
-
-            // Stagger logins
-            Thread.Sleep(LoginDelay);
+            m_bots.Add(pb);
         }
 
         /// <summary>
@@ -259,52 +436,270 @@ namespace pCampBot
             switch (eventt)
             {
                 case EventType.CONNECTED:
+                {
                     m_log.Info("[" + callbot.FirstName + " " + callbot.LastName + "]: Connected");
                     break;
+                }
+
                 case EventType.DISCONNECTED:
+                {
                     m_log.Info("[" + callbot.FirstName + " " + callbot.LastName + "]: Disconnected");
+                    break;
+                }
+            }
+        }
 
-                    lock (m_lBot)
-                    {
-                        if (m_lBot.TrueForAll(b => b.ConnectionState == ConnectionState.Disconnected))
-                            Environment.Exit(0);
+        /// <summary>
+        /// Standard CreateConsole routine
+        /// </summary>
+        /// <returns></returns>
+        protected CommandConsole CreateConsole()
+        {
+            return new LocalConsole("pCampbot");
+        }
 
-                        break;
+        private void HandleConnect(string module, string[] cmd)
+        {
+            if (ConnectingBots)
+            {
+                MainConsole.Instance.Output("Still connecting bots.  Please wait for previous process to complete.");
+                return;
+            }
+
+            lock (m_bots)
+            {
+                int botsToConnect;
+                int disconnectedBots = m_bots.Count(b => b.ConnectionState == ConnectionState.Disconnected);
+
+                if (cmd.Length == 1)
+                {
+                    botsToConnect = disconnectedBots;
+                }
+                else
+                {
+                    if (!ConsoleUtil.TryParseConsoleNaturalInt(MainConsole.Instance, cmd[1], out botsToConnect))
+                        return;
+
+                    botsToConnect = Math.Min(botsToConnect, disconnectedBots);
+                }
+
+                MainConsole.Instance.OutputFormat("Connecting {0} bots", botsToConnect);
+
+                ConnectBots(botsToConnect);
+            }
+        }
+
+        private void HandleAddBehaviour(string module, string[] cmd)
+        {
+            if (cmd.Length < 3 || cmd.Length > 4)
+            {
+                MainConsole.Instance.OutputFormat("Usage: add behaviour <abbreviated-behaviour> [<bot-number>]");
+                return;
+            }
+
+            string rawBehaviours = cmd[2];
+
+            List<Bot> botsToEffect = new List<Bot>();
+
+            if (cmd.Length == 3)
+            {
+                lock (m_bots)
+                    botsToEffect.AddRange(m_bots);
+            }
+            else
+            {
+                int botNumber;
+                if (!ConsoleUtil.TryParseConsoleNaturalInt(MainConsole.Instance, cmd[3], out botNumber))
+                    return;
+
+                Bot bot = GetBotFromNumber(botNumber);
+
+                if (bot == null)
+                {
+                    MainConsole.Instance.OutputFormat("Error: No bot found with number {0}", botNumber);
+                    return;
+                }
+
+                botsToEffect.Add(bot);
+            }
+
+
+            HashSet<string> rawAbbreviatedSwitchesToAdd = new HashSet<string>();
+            Array.ForEach<string>(rawBehaviours.Split(new char[] { ',' }), b => rawAbbreviatedSwitchesToAdd.Add(b));
+
+            foreach (Bot bot in botsToEffect)
+            {
+                List<IBehaviour> behavioursAdded = new List<IBehaviour>();
+
+                foreach (IBehaviour behaviour in CreateBehavioursFromAbbreviatedNames(rawAbbreviatedSwitchesToAdd))
+                {
+                    if (bot.AddBehaviour(behaviour))
+                        behavioursAdded.Add(behaviour);
+                }
+
+                MainConsole.Instance.OutputFormat(
+                    "Added behaviours {0} to bot {1}", 
+                    string.Join(", ", behavioursAdded.ConvertAll<string>(b => b.Name).ToArray()), bot.Name);
+            }
+        }
+
+        private void HandleRemoveBehaviour(string module, string[] cmd)
+        {
+            if (cmd.Length < 3 || cmd.Length > 4)
+            {
+                MainConsole.Instance.OutputFormat("Usage: remove behaviour <abbreviated-behaviour> [<bot-number>]");
+                return;
+            }
+
+            string rawBehaviours = cmd[2];
+
+            List<Bot> botsToEffect = new List<Bot>();
+
+            if (cmd.Length == 3)
+            {
+                lock (m_bots)
+                    botsToEffect.AddRange(m_bots);
+            }
+            else
+            {
+                int botNumber;
+                if (!ConsoleUtil.TryParseConsoleNaturalInt(MainConsole.Instance, cmd[3], out botNumber))
+                    return;
+
+                Bot bot = GetBotFromNumber(botNumber);
+
+                if (bot == null)
+                {
+                    MainConsole.Instance.OutputFormat("Error: No bot found with number {0}", botNumber);
+                    return;
+                }
+
+                botsToEffect.Add(bot);
+            }
+
+            HashSet<string> abbreviatedBehavioursToRemove = new HashSet<string>();
+            Array.ForEach<string>(rawBehaviours.Split(new char[] { ',' }), b => abbreviatedBehavioursToRemove.Add(b));
+
+            foreach (Bot bot in botsToEffect)
+            {
+                List<IBehaviour> behavioursRemoved = new List<IBehaviour>();
+
+                foreach (string b in abbreviatedBehavioursToRemove)
+                {
+                    IBehaviour behaviour;
+
+                    if (bot.TryGetBehaviour(b, out behaviour))
+                    {
+                        bot.RemoveBehaviour(b);
+                        behavioursRemoved.Add(behaviour);
                     }
+                }
+
+                MainConsole.Instance.OutputFormat(
+                    "Removed behaviours {0} to bot {1}", 
+                    string.Join(", ", behavioursRemoved.ConvertAll<string>(b => b.Name).ToArray()), bot.Name);
             }
         }
 
-        /// <summary>
-        /// Shut down all bots
-        /// </summary>
-        /// <remarks>
-        /// We launch each shutdown on its own thread so that a slow shutting down bot doesn't hold up all the others.
-        /// </remarks>
-        public void doBotShutdown()
+        private void HandleDisconnect(string module, string[] cmd)
         {
-            lock (m_lBot)
+            lock (m_bots)
             {
-                foreach (Bot bot in m_lBot)
+                int botsToDisconnect;
+                int connectedBots = m_bots.Count(b => b.ConnectionState == ConnectionState.Connected);
+
+                if (cmd.Length == 1)
                 {
-                    Bot thisBot = bot;
-                    Util.FireAndForget(o => thisBot.shutdown());
+                    botsToDisconnect = connectedBots;
                 }
+                else
+                {
+                    if (!ConsoleUtil.TryParseConsoleNaturalInt(MainConsole.Instance, cmd[1], out botsToDisconnect))
+                        return;
+
+                    botsToDisconnect = Math.Min(botsToDisconnect, connectedBots);
+                }
+
+                DisconnectingBots = true;
+
+                MainConsole.Instance.OutputFormat("Disconnecting {0} bots", botsToDisconnect);
+
+                int disconnectedBots = 0;
+
+                for (int i = m_bots.Count - 1; i >= 0; i--)
+                {
+                    if (disconnectedBots >= botsToDisconnect)
+                        break;
+
+                    Bot thisBot = m_bots[i];
+
+                    if (thisBot.ConnectionState == ConnectionState.Connected)
+                    {
+                        Util.FireAndForget(o => thisBot.Disconnect());
+                        disconnectedBots++;
+                    }
+                }
+
+                DisconnectingBots = false;
             }
         }
 
-        /// <summary>
-        /// Standard CreateConsole routine
-        /// </summary>
-        /// <returns></returns>
-        protected CommandConsole CreateConsole()
+        private void HandleSit(string module, string[] cmd)
         {
-            return new LocalConsole("pCampbot");
+            lock (m_bots)
+            {
+                m_bots.ForEach(b => b.SitOnGround());
+            }
+        }
+
+        private void HandleStand(string module, string[] cmd)
+        {
+            lock (m_bots)
+            {
+                m_bots.ForEach(b => b.Stand());
+            }
         }
 
         private void HandleShutdown(string module, string[] cmd)
         {
-            m_log.Info("[BOTMANAGER]: Shutting down bots");
-            doBotShutdown();
+            lock (m_bots)
+            {
+                int connectedBots = m_bots.Count(b => b.ConnectionState == ConnectionState.Connected);
+
+                if (connectedBots > 0)
+                {
+                    MainConsole.Instance.OutputFormat("Please disconnect {0} connected bots first", connectedBots);
+                    return;
+                }
+            }
+
+            MainConsole.Instance.Output("Shutting down");
+
+            Environment.Exit(0);
+        }
+
+        private void HandleSetBots(string module, string[] cmd)
+        {
+            string key = cmd[2];
+            string rawValue = cmd[3];
+
+            if (key == "SEND_AGENT_UPDATES")
+            {   
+                bool newSendAgentUpdatesSetting;
+
+                if (!ConsoleUtil.TryParseConsoleBool(MainConsole.Instance, rawValue, out newSendAgentUpdatesSetting))
+                    return;
+
+                MainConsole.Instance.OutputFormat(
+                    "Setting SEND_AGENT_UPDATES to {0} for all bots", newSendAgentUpdatesSetting);
+
+                lock (m_bots)
+                    m_bots.ForEach(b => b.Client.Settings.SEND_AGENT_UPDATES = newSendAgentUpdatesSetting);
+            }
+            else
+            {
+                MainConsole.Instance.Output("Error: Only setting currently available is SEND_AGENT_UPDATES");
+            }
         }
 
         private void HandleShowRegions(string module, string[] cmd)
@@ -322,43 +717,114 @@ namespace pCampBot
             }
         }
 
-        private void HandleShowStatus(string module, string[] cmd)
+        private void HandleShowBotsStatus(string module, string[] cmd)
         {
-            string outputFormat = "{0,-30}  {1, -30}  {2,-14}";
-            MainConsole.Instance.OutputFormat(outputFormat, "Name", "Region", "Status");
-
-            lock (m_lBot)
+            ConsoleDisplayTable cdt = new ConsoleDisplayTable();
+            cdt.AddColumn("Name", 24);
+            cdt.AddColumn("Region", 24);
+            cdt.AddColumn("Status", 13);
+            cdt.AddColumn("Conns", 5);
+            cdt.AddColumn("Behaviours", 20);
+
+            Dictionary<ConnectionState, int> totals = new Dictionary<ConnectionState, int>();
+            foreach (object o in Enum.GetValues(typeof(ConnectionState)))
+                totals[(ConnectionState)o] = 0;
+
+            lock (m_bots)
             {
-                foreach (Bot pb in m_lBot)
+                foreach (Bot bot in m_bots)
                 {
-                    Simulator currentSim = pb.Client.Network.CurrentSim;
-
-                    MainConsole.Instance.OutputFormat(
-                        outputFormat,
-                        pb.Name, currentSim != null ? currentSim.Name : "(none)", pb.ConnectionState);
+                    Simulator currentSim = bot.Client.Network.CurrentSim;
+                    totals[bot.ConnectionState]++;
+
+                    cdt.AddRow(
+                        bot.Name, 
+                        currentSim != null ? currentSim.Name : "(none)", 
+                        bot.ConnectionState, 
+                        bot.SimulatorsCount, 
+                        string.Join(",", bot.Behaviours.Keys.ToArray()));
                 }
             }
+
+            MainConsole.Instance.Output(cdt.ToString());
+
+            ConsoleDisplayList cdl = new ConsoleDisplayList();
+
+            foreach (KeyValuePair<ConnectionState, int> kvp in totals)
+                cdl.AddRow(kvp.Key, kvp.Value);
+
+            MainConsole.Instance.Output(cdl.ToString());
         }
 
-        /*
-        private void HandleQuit(string module, string[] cmd)
+        private void HandleShowBotStatus(string module, string[] cmd)
         {
-            m_console.Warn("DANGER", "This should only be used to quit the program if you've already used the shutdown command and the program hasn't quit");
-            Environment.Exit(0);
+            if (cmd.Length != 3)
+            {
+                MainConsole.Instance.Output("Usage: show bot <n>");
+                return;
+            }
+
+            int botNumber;
+
+            if (!ConsoleUtil.TryParseConsoleInt(MainConsole.Instance, cmd[2], out botNumber))
+                return;
+
+            Bot bot = GetBotFromNumber(botNumber);
+
+            if (bot == null)
+            {
+                MainConsole.Instance.OutputFormat("Error: No bot found with number {0}", botNumber);
+                return;
+            }
+
+            ConsoleDisplayList cdl = new ConsoleDisplayList();
+            cdl.AddRow("Name", bot.Name);
+            cdl.AddRow("Status", bot.ConnectionState);
+
+            Simulator currentSim = bot.Client.Network.CurrentSim;
+            cdl.AddRow("Region", currentSim != null ? currentSim.Name : "(none)");
+
+            List<Simulator> connectedSimulators = bot.Simulators;
+            List<string> simulatorNames = connectedSimulators.ConvertAll<string>(cs => cs.Name);
+            cdl.AddRow("Connections", string.Join(", ", simulatorNames.ToArray()));
+
+            MainConsole.Instance.Output(cdl.ToString());
+
+            MainConsole.Instance.Output("Settings");
+
+            ConsoleDisplayList statusCdl = new ConsoleDisplayList();
+
+            statusCdl.AddRow(
+                "Behaviours", 
+                string.Join(", ", bot.Behaviours.Values.ToList().ConvertAll<string>(b => b.Name).ToArray()));
+
+            GridClient botClient = bot.Client;
+            statusCdl.AddRow("SEND_AGENT_UPDATES", botClient.Settings.SEND_AGENT_UPDATES);
+
+            MainConsole.Instance.Output(statusCdl.ToString());
+        }
+
+        /// <summary>
+        /// Get a specific bot from its number.
+        /// </summary>
+        /// <returns>null if no bot was found</returns>
+        /// <param name='botNumber'></param>
+        private Bot GetBotFromNumber(int botNumber)
+        {
+            string name = GenerateBotNameFromNumber(botNumber);
+
+            Bot bot;
+
+            lock (m_bots)
+                bot = m_bots.Find(b => b.Name == name);
+
+            return bot;
+        }
+
+        private string GenerateBotNameFromNumber(int botNumber)
+        {
+            return string.Format("{0} {1}_{2}", m_firstName, m_lastNameStem, botNumber);
         }
-        */
-//
-//        private void HandleAddBots(string module, string[] cmd)
-//        {
-//            int newbots = 0;
-//            
-//            if (cmd.Length > 2)
-//            {
-//                Int32.TryParse(cmd[2], out newbots);
-//            }
-//            if (newbots > 0)
-//                addbots(newbots);
-//        }
 
         internal void Grid_GridRegion(object o, GridRegionEventArgs args)
         {
@@ -379,4 +845,4 @@ namespace pCampBot
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Tools/pCampBot/Interfaces/IBehaviour.cs b/OpenSim/Tools/pCampBot/Interfaces/IBehaviour.cs
index 9c984be..0ed4825 100644
--- a/OpenSim/Tools/pCampBot/Interfaces/IBehaviour.cs
+++ b/OpenSim/Tools/pCampBot/Interfaces/IBehaviour.cs
@@ -32,6 +32,11 @@ namespace pCampBot.Interfaces
     public interface IBehaviour
     {
         /// <summary>
+        /// Abbreviated name of this behaviour. 
+        /// </summary>
+        string AbbreviatedName { get; }
+
+        /// <summary>
         /// Name of this behaviour.
         /// </summary>
         string Name { get; }
@@ -46,6 +51,14 @@ namespace pCampBot.Interfaces
         void Initialize(Bot bot);
 
         /// <summary>
+        /// Close down this behaviour.
+        /// </summary>
+        /// <remarks>
+        /// This is triggered if a behaviour is removed via explicit command and when a bot is disconnected
+        /// </remarks>
+        void Close();
+
+        /// <summary>
         /// Action to take when this behaviour is invoked.
         /// </summary>
         /// <param name="bot"></param>
diff --git a/OpenSim/Tools/pCampBot/pCampBot.cs b/OpenSim/Tools/pCampBot/pCampBot.cs
index 9e82577..781bb00 100644
--- a/OpenSim/Tools/pCampBot/pCampBot.cs
+++ b/OpenSim/Tools/pCampBot/pCampBot.cs
@@ -26,6 +26,7 @@
  */
 
 using System;
+using System.IO;
 using System.Reflection;
 using System.Threading;
 using log4net;
@@ -50,30 +51,62 @@ namespace pCampBot
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        public const string ConfigFileName = "pCampBot.ini";
+
         [STAThread]
         public static void Main(string[] args)
         {
             XmlConfigurator.Configure();
 
-            IConfig config = ParseConfig(args);
-            if (config.Get("help") != null || config.Get("loginuri") == null)
+            IConfig commandLineConfig = ParseConfig(args);
+            if (commandLineConfig.Get("help") != null || commandLineConfig.Get("loginuri") == null)
             {
                 Help();
             }
-            else if (config.Get("firstname") == null ||  config.Get("lastname") == null || config.Get("password") == null)
+            else if (
+                commandLineConfig.Get("firstname") == null 
+                    ||  commandLineConfig.Get("lastname") == null 
+                    || commandLineConfig.Get("password") == null)
             {
                 Console.WriteLine("ERROR: You must supply a firstname, lastname and password for the bots.");
             }
             else
             {
-                int botcount = config.GetInt("botcount", 1);
-
                 BotManager bm = new BotManager();
 
-                //startup specified number of bots.  1 is the default
-                Thread startBotThread = new Thread(o => bm.dobotStartup(botcount, config));
-                startBotThread.Name = "Initial start bots thread";
-                startBotThread.Start();
+                string iniFilePath = Path.GetFullPath(Path.Combine(Util.configDir(), ConfigFileName));
+
+                if (File.Exists(iniFilePath))
+                {
+                    m_log.InfoFormat("[PCAMPBOT]: Reading configuration settings from {0}", iniFilePath);
+
+                    IConfigSource configSource = new IniConfigSource(iniFilePath);
+
+                    IConfig botManagerConfig = configSource.Configs["BotManager"];
+
+                    if (botManagerConfig != null)
+                    {
+                        bm.LoginDelay = botManagerConfig.GetInt("LoginDelay", bm.LoginDelay);
+                    }
+
+                    IConfig botConfig = configSource.Configs["Bot"];
+
+                    if (botConfig != null)
+                    {
+                        bm.InitBotSendAgentUpdates 
+                            = botConfig.GetBoolean("SendAgentUpdates", bm.InitBotSendAgentUpdates);
+                        bm.InitBotRequestObjectTextures
+                            = botConfig.GetBoolean("RequestObjectTextures", bm.InitBotRequestObjectTextures);
+                    }
+                }
+
+                int botcount = commandLineConfig.GetInt("botcount", 1);
+                bool startConnected = commandLineConfig.Get("connect") != null;
+
+                bm.CreateBots(botcount, commandLineConfig);
+
+                if (startConnected)
+                    bm.ConnectBots(botcount);
 
                 while (true)
                 {
@@ -94,8 +127,11 @@ namespace pCampBot
             //Set up our nifty config..  thanks to nini
             ArgvConfigSource cs = new ArgvConfigSource(args);
 
+            cs.AddSwitch("Startup", "connect", "c");
             cs.AddSwitch("Startup", "botcount", "n");
+            cs.AddSwitch("Startup", "from", "f");
             cs.AddSwitch("Startup", "loginuri", "l");
+            cs.AddSwitch("Startup", "start", "s");
             cs.AddSwitch("Startup", "firstname");
             cs.AddSwitch("Startup", "lastname");
             cs.AddSwitch("Startup", "password");
@@ -113,22 +149,27 @@ namespace pCampBot
             // You can either say no, to not load anything, yes, to load one of the default wearables, a folder
             // name, to load an specific folder, or save, to save an avatar with some already existing wearables
             // worn to the folder MyAppearance/FirstName_LastName, and the load it.
+
             Console.WriteLine(
-                "usage: pCampBot <-loginuri loginuri> [OPTIONS]\n" +
-                "Spawns a set of bots to test an OpenSim region\n\n" +
-                "  -l, -loginuri      loginuri for sim to log into (required)\n" +
-                "  -n, -botcount      number of bots to start (default: 1)\n" +
-                "  -firstname         first name for the bots\n" +
-                "  -lastname          lastname for the bots.  Each lastname will have _<bot-number> appended, e.g. Ima Bot_0\n" +
-                "  -password          password for the bots\n" +
-                "  -b, behaviours     behaviours for bots.  Comma separated, e.g. p,g.  Default is p\n" +
-                "    current options are:\n" +
-                "       p (physics)\n" +
-                "       g (grab)\n" +
-                "       t (teleport)\n" +
-//                "       c (cross)" +
-                "  -wear              set appearance folder to load from (default: no)\n" +
-                "  -h, -help          show this message");
+                "usage: pCampBot <-loginuri loginuri> [OPTIONS]\n"
+                    + "Spawns a set of bots to test an OpenSim region\n\n"
+                    + "  -l, -loginuri      loginuri for grid/standalone (required)\n"
+                    + "  -s, -start         start location for bots (optional).  Can be \"last\", \"home\" or a specific location with or without co-ords (e.g. \"region1\" or \"region2/50/30/90\"\n"
+                    + "  -firstname         first name for the bots (required)\n"
+                    + "  -lastname          lastname for the bots (required).  Each lastname will have _<bot-number> appended, e.g. Ima Bot_0\n"
+                    + "  -password          password for the bots (required)\n"
+                    + "  -n, -botcount      number of bots to start (default: 1) (optional)\n"
+                    + "  -f, -from          starting number for login bot names, e.g. 25 will login Ima Bot_25, Ima Bot_26, etc.  (default: 0) (optional)\n"
+                    + "  -c, -connect       connect all bots at startup (optional)\n"
+                    + "  -b, behaviours     behaviours for bots.  Comma separated, e.g. p,g.  Default is p (required)\n"
+                    + "    current options are:\n"
+                    + "       p (physics  - bots constantly move and jump around)\n"
+                    + "       g (grab     - bots randomly click prims whether set clickable or not)\n"
+                    + "       n (none     - bots do nothing)\n"
+                    + "       t (teleport - bots regularly teleport between regions on the grid)\n"
+//                "       c (cross)\n" +
+                    + "  -wear              folder from which to load appearance data, \"no\" if there is no such folder (default: no) (optional)\n"
+                    + "  -h, -help          show this message.\n");
         }
     }
 }