public bool Handle(ChatMessage message, IBot bot)
 {
     try
     {
         using (var _database = new TwitterNotifierSprocketRepository())
         {
             _database.RecordActivity(message.FromUser);
             InviteUserIfNeccessary(message.FromUser, bot, _database);
             var twitterUsers = GetUserNamesFromMessage(message.Content, _database);
             var user = _database.FetchOrCreateUser(message.FromUser);
             if (twitterUsers.Count() > 0)
             {
                 foreach (var u in twitterUsers)
                 {
                     if (ShouldNotifyUser(u.ScreenName, _database))
                     {
                         NotifyUserOnTwitter(message, user, u);
                         _database.MarkUserNotified(u.ScreenName);
                     }
                 }
                 return true;
             }
         }
     }
     catch (Exception e)
     {
         bot.PrivateReply(message.FromUser, e.GetBaseException().Message);
     }
     return false;
 }

 private static void CheckForkStatus(KeyValuePair<dynamic, dynamic> fork, IDictionary<string, string> existingForkStatus, IBot bot)
 {
     string id = fork.Key.ToString();
     string url = fork.Value.ToString() + "/commits";
     var commits = url.GetResponse<IEnumerable<dynamic>>().ToList();
     bot.ProcessForkStatus(id, existingForkStatus, commits);
 }

		/// <summary>Runs the bot.</summary>
		public static void Run(IBot bot)
		{
			using (var platform = new ConsolePlatform())
			{
				platform.DoRun(bot);
			}
		}

        public Sequence this[IBot.IBot bot]
        {
            get
            {
                var seq = new Sequence(

                    new Decorator(ret => bot.isRunning, new TreeSharp.Action(ret => RunStatus.Success)),
                    
                    //first we must have a valid target
                    new Decorator(ret => Util.Targeting.HasValidTarget(bot.CurrentTarget), new TreeSharp.Action(ret => RunStatus.Success)),

                    //if we are already busy, don't continue.
                    new Decorator(ret => !bot.isInAction, new TreeSharp.Action(ret => RunStatus.Success)),


                    //send the attack action.
                    new TreeSharp.Action(ret =>
                    {
                        bot.Attack(bot.CurrentTarget);
                    }),

                    //wait for the action to complete (or we time out).
                    new Wait(1, ret => bot.isInAction, new TreeSharp.Action(ret => RunStatus.Success))
            );

                return seq;

            }

        }

        // When the bot stops, output a final item-stats report so it is as up-to-date as can be
        private void FunkyBotStop(IBot bot)
        {
            // Issue final reports
            OutputReport();

            PlayerMover.iTotalAntiStuckAttempts = 1;
            PlayerMover.vSafeMovementLocation = Vector3.Zero;
            PlayerMover.vOldPosition = Vector3.Zero;
            PlayerMover.iTimesReachedStuckPoint = 0;
            PlayerMover.timeLastRecordedPosition = DateTime.Today;
            PlayerMover.timeStartedUnstuckMeasure = DateTime.Today;
            hashUseOnceID = new HashSet<int>();
            dictUseOnceID = new Dictionary<int, int>();
            dictRandomID = new Dictionary<int, int>();
                Bot.Stats.iMaxDeathsAllowed=0;
                Bot.Stats.iDeathsThisRun=0;
                initTreeHooks=false;
            //Total Stats
                Bot.BotStatistics.ItemStats.Update();
                Bot.BotStatistics.GameStats.Update();
                Bot.BotStatistics.ProfileStats.OutputReport();

                RemoveHandlers();
                ResetTreehooks();
        }

		/// <summary>Runs it all.</summary>
		public void DoRun(IBot bot, IEnumerable<IInstruction> instructions)
		{
			if (bot == null) { throw new ArgumentNullException("bot"); }
			if (instructions == null) { throw new ArgumentNullException("instructions"); }

			var settings = new Settings();
			var state = new GameState();

			foreach (var instruction in instructions)
			{
				if (settings.Apply(instruction))
				{
					bot.ApplySettings(settings);
				}
				else if (state.Apply(instruction)) { }
				else if (instruction is RequestMoveInstruction)
				{
					bot.Update(state);
					try
					{
						var response = bot.GetResponse(((RequestMoveInstruction)instruction).Time);
						Writer.WriteLine(response.Move);
						if (!String.IsNullOrEmpty(response.Log))
						{
							Logger.WriteLine(response.Log);
						}
					}
					catch (Exception x)
					{
						Writer.WriteLine(new MoveInstruction(Move.Center));
						Logger.WriteLine(x);
					}
				}
			}
		}

    public new IProcessingResult Command(IBot bot, IProcessingResult pr, IChatMessage msg, string cmd, string arg, string cmdOriginal, string argOriginal)
    {
        switch (cmd)
        {
            default: return pr;

            // core commands

            case "about": return About(bot, pr, arg);
            case "help": return Help(bot, pr, arg);
            case "commands": return GetCommandList(bot, pr, arg);
            case "uptime": return Uptime(bot, pr);
            case "modules": return Modules(bot, pr);

            case "edit": return Edit(pr, bot, msg, arg);
            case "unonebox":
            case "unbox": return Unonebox(pr, bot, msg, arg);
            case "undo": return Undo(bot, pr, arg);

            case "status": return Status(bot, pr);

            case "trust": return TrustedUsers(bot, pr, arg);
            case "ignore": return BannedUsers(bot, pr, arg);

            case "say": return Say(pr, arg);
            case "tell": return Tell(pr, arg);

            case "alias": return Alias(pr, bot, msg, arg);

            case "save": return Save(bot, pr, msg.UserID);
            case "shutdown": return Shutdown(bot, pr, arg, msg.UserID);


            // hoihoi-san borrowed

            case "google": return Google(pr, msg, arg);
            case "wiki": return Wiki(pr, msg, arg);
            case "urban": return Urban(pr, msg, arg);
            case "youtube": return Youtube(pr, msg, arg);
            case "weather": return Weather(pr, msg, arg);


            // advanfaged

            case "id": return ID(bot, pr, msg, arg);
            case "isch": return Isch(bot, pr, msg, arg);

            case "whois":
            case "what":
            case "last": return LastPostedImageID(bot, pr, msg, arg);


            // bonus

            case "hats": return Hats(pr);
            case "meme": return Meme(bot, pr, msg, arg);

        }
    }

 public ASubBot(IBot bot)
 {
     this.InitializeComponent();
     this.bot = bot;
     this.updateTimer = new System.Timers.Timer();
     updateTimer.Elapsed += delegate {
         onTick(); };
 }

 public void Loaded(IPlugin plugin, IBot bot)
 {
     foreach(AliasData alias in Aliases)
     {
         IExpression aliasExpression = Parse(bot.Command, alias.Expression);
         Add(bot.Command, plugin, alias, aliasExpression, false);
     }
 }

 private static IEnumerable<string> GetAllUsersInSameRoomsAsJibber(IBot bot)
 {
     var rooms = GetRooms(bot);
     var users = rooms.SelectMany<dynamic, dynamic>(r => r.Users);
     var userNames = users.Select(u => u.Name);
     var distinctUserNames = userNames.Distinct().Cast<string>();
     return distinctUserNames;
 }

        //: base(bot, id, name, smiley, xPos, yPos, isGod, isMod, hasChat, coins, purple, isFriend, level)
        public Player(IBot bot, int id, string name, int smiley, double xPos, double yPos, bool isGod, bool isMod, bool hasChat, int coins, bool purple, bool isFriend, int level)
        {
            this.id = id;
            this.bot = bot;

            physicsPlayer = new PhysicsPlayer(bot, id, name, smiley, xPos, yPos, isGod, isMod, hasChat, coins, purple, isFriend, level);
            afkStopwatch.Start();
        }

 private void FunkyBotStart(IBot bot)
 {
     if (!ErrorClickerThread.ThreadState.HasFlag(ThreadState.Running))
         {
              ErrorClickerThread.Start();
              DBLog.Info("[Funky] Error Clicking Thread Started.");
         }
 }

 public BlockMap(IBot bot, int width = 0, int height = 0)
 {
     backgroundMap = new Stack<IBlock>[width + 1, height + 1];
     foregroundMap = new Stack<IBlock>[width + 1, height + 1];
     currentForegroundMap = new int[width + 1, height + 1];
     this.width = width;
     this.height = height;
     Reset();
 }

        public FurnitureManager(IBot bot)
        {
            this.bot = bot;

            furnitureTypes.Add("door", new FurnitureDoor(0, 0));
            furnitureTypes.Add("switch", new FurnitureSwitch(0, 0));
            furnitureTypes.Add("switchdoor", new FurnitureSwitchDoor(0, 0));
            furnitureTypes.Add("empty", new FurnitureEmpty(0, 0));
            furnitureTypes.Add("spawn", new FurnitureSpawn(0, 0));
        }

 public Minimap(IBot bot, int width, int height)
     : base(bot)
 {
     this.bot = bot;
     this.width = width;
     this.height = height;
     this.bitmap = new Bitmap(width, height);
     updateThread = new SafeThread(UpdateMinimap);
     updateThread.Start();
 }

        public HouseBuilding(IBot bot)
            : base(bot)
        {
            this.furnitureManager = new FurnitureManager(bot);
            this.houseManager = new HouseManager(bot);

            HouseType tinyHouse = new HouseType("tinyhouse", 7, 7, 46, 48, 541);
            tinyHouse.AddCost("stone", 25);
            HouseType smallHouse = new HouseType("smallhouse", 9, 9, 93, 93);
            smallHouse.AddCost("stone", 100);
            HouseType mediumHouse = new HouseType("mediumhouse", 11, 11, 1023, 1024);
            mediumHouse.AddCost("stone", 400);
            mediumHouse.AddCost("copper", 20);
            HouseType largeHouse = new HouseType("largehouse", 13, 13, 14, 1018, 505);
            largeHouse.AddCost("stone", 600);
            largeHouse.AddCost("iron", 30);
            HouseType veryLargeHouse = new HouseType("verylargehouse", 15, 15, 1021, 42);
            veryLargeHouse.AddCost("stone", 800);
            veryLargeHouse.AddCost("gold", 50);
            HouseType hugeHouse = new HouseType("hugehouse", 17, 17, 196, 195, 618);
            hugeHouse.AddCost("stone", 1000);
            hugeHouse.AddCost("copper", 50);
            hugeHouse.AddCost("iron", 50);
            hugeHouse.AddCost("gold", 50);

            HouseType weirdHouse = new HouseType("weirdhouse", 17, 5, 80, 82, 548);
            weirdHouse.AddCost("stone", 400);
            HouseType strangeHouse = new HouseType("strangehouse", 3, 15, 50, 156, 575);
            strangeHouse.AddCost("stone", 300);
            HouseType candyHouse = new HouseType("candyhouse", 11, 11, 67, 60, 539);
            candyHouse.AddCost("stone", 400);
            candyHouse.AddCost("copper", 50);
            HouseType basicHouse = new HouseType("basichouse", 11, 11, 9, 10, 501);
            basicHouse.AddCost("stone", 400);
            HouseType brickHouse = new HouseType("brickhouse", 11, 11, 1024, 1023, 647);
            brickHouse.AddCost("stone", 400);
            HouseType coinHouse = new HouseType("coinhouse", 5, 5, 41, 100, 581);
            coinHouse.AddCost("stone", 400);

            this.houseManager.RegisterHouseType(tinyHouse);
            this.houseManager.RegisterHouseType(smallHouse);
            this.houseManager.RegisterHouseType(mediumHouse);
            this.houseManager.RegisterHouseType(largeHouse);
            this.houseManager.RegisterHouseType(veryLargeHouse);
            this.houseManager.RegisterHouseType(hugeHouse);

            this.houseManager.RegisterHouseType(weirdHouse);
            this.houseManager.RegisterHouseType(strangeHouse);
            this.houseManager.RegisterHouseType(candyHouse);
            this.houseManager.RegisterHouseType(basicHouse);
            this.houseManager.RegisterHouseType(brickHouse);
            this.houseManager.RegisterHouseType(coinHouse);

            EnableTick(5000);
        }

        public ModuleService(IBot bot)
        {
            this.bot = bot;

            this.storageCatalog = new AzureStorageCatalog(string.Empty, string.Empty);
            this.aggregateCatalog = new AggregateCatalog(this.storageCatalog);
            this.moduleContainer = new CompositionContainer(this.aggregateCatalog);

            this.moduleContainer.ExportsChanged += this.ModuleContainerOnExportsChanged;
            this.storageCatalog.Changed += this.StorageCatalogOnChanged;
        }

        public void ExecuteTask(IBot bot, string baseUrl, string repositoryName)
        {
            var url = baseUrl.Append(ProjectWatchersFeed);
            var currentWatchers = url.GetResponse<IEnumerable<dynamic>>();
            var existingWatchers = _settings.GetValue<IList<string>>(WatchersKey, () => new List<string>());

            existingWatchers = bot.ProcessWatchers(repositoryName, existingWatchers, currentWatchers);

            _settings.Set(WatchersKey, existingWatchers);
            _settings.Save();
        }

        public void Loaded(IPlugin plugin, IBot bot)
        {
            foreach(MessageParserData data in Data)
            {
                Regex regex = ParseRegex(data.Pattern);
                IExpression expression = ParseExpression(bot.Command, data.Expression);
                Add(data, regex, expression, false);
            }

            _messageDisposable = bot.Messages.Subscribe(ParseMessage);
        }

		/// <summary>Runs it all.</summary>
		public void DoRun(IBot bot)
		{
			if (bot == null) { throw new ArgumentNullException("bot"); }

			var settings = new Settings();
			var match = new GameState(settings);

			string line;
			while ((line = this.Reader.ReadLine()) != null)
			{
#if !DEBUG
				try
				{
#endif
				var instruction = Instruction.Parse(line);

				switch (instruction.InstructionType)
				{
					case InstructionType.Player:
						match.UpdatePlayer(instruction);
						HandleOpponentReaction(bot, match, instruction);
						if (match.Result != RoundResult.NoResult)
						{
							bot.Result(match);
						}
						break;
					case InstructionType.Match: match.UpdateMatch(instruction); break;

					case InstructionType.Settings:
						settings.Update(instruction);
						match.Update(settings);
						break;

					case InstructionType.Action:
						match.UpdateAction(instruction);
						var action = bot.Action(match);
						Writer.WriteLine(action);
						break;

					case InstructionType.None:
					case InstructionType.Output:
					default:
						break;
				}
#if !DEBUG
				}
				catch (Exception x)
				{
					Console.Error.WriteLine(line);
					Console.Error.WriteLine(x);
				}
#endif
			}
		}