public override void Initialize(Bot Bot)
 {
     mSelfBot = Bot;
     mCurrentAction = PetBotAction.Idle;
     mActionStartedTimestamp = UnixTimestamp.GetCurrent();
     mPossibleTricks = PetDataManager.GetTricksForType(Bot.PetData.Type);
 }

 public void GroupRun(SteamFriends.ChatMsgCallback callback, Bot bot, object[] args = null)
 {
     List<string> strings = new List<string>(callback.Message.Split(' '));
     strings.RemoveAt(0);
     string company = String.Join(" ", strings.ToArray());
     bot.ChatroomMessage(bot.chatRoomID, Util.GetYahooStocks(company));
 }

        public static void cmd_cycle(Bot bot, String ns, String[] args, String msg, String from, dAmnPacket packet)
        {
            var chan = "";

            if (args.Length > 1 && args[1].StartsWith("#"))
            {
                chan = args[1];
            }
            else
            {
                chan = ns;
            }

            String cpns = Tools.FormatNamespace(chan, Types.NamespaceFormat.Packet).ToLower();

            if (!Core.ChannelData.ContainsKey(cpns))
            {
                bot.Say(ns, "<b>&raquo; It doesn't look like I'm in that channel.</b>");
                return;
            }

            lock (CommandChannels["part"])
            {
                CommandChannels["part"].Add(ns);
            }

            lock (CommandChannels["join"])
            {
                CommandChannels["join"].Add(ns);
            }

            bot.Part(cpns);
            bot.Join(cpns);
        }

		static public ITaskParam TravelInfoPanelRouteConditional(Bot Bot)
		{
			var MemoryMeasurement = Bot?.SequenceStepLastState()?.MemoryMeasurement?.Wert;

			var InfoPanelRoute = MemoryMeasurement.InfoPanelRoute();

			//	from the set of Waypoint markers in the Info Panel pick the one that represents the next Waypoint/System.
			//	We assume this is the one which is nearest to the topleft corner of the Screen which is at (0,0)
			var WaypointMarkerNext =
				InfoPanelRoute?.WaypointMarker
				?.OrderByCenterDistanceToPoint(new Vektor2DInt(0, 0))
				?.FirstOrDefault();

			if (null == WaypointMarkerNext)
			{
				return new ToClientStatusParam("no route in InfoPanel.", TaskStatusEnum.Idle);
			}

			if ((Bot?.LastOcurrenceAge(BotInstant =>
				(BotInstant.ShipState()?.ManeuverType?.Docked() ?? false)) ?? int.MaxValue) < TravelInfoPanelRouteParam.ShipTransitionSettlingTime)
			{
				return new ToClientStatusParam("char is docked, no action required.", TaskStatusEnum.Idle);
			}

			return
				new SequentialParam(
					new ITaskParam[]
					{
						new WaitUntilShipManeuverPossible(),
						new MenuPathParam(WaypointMarkerNext, new[] { TravelInfoPanelRouteParam.MenuEntryRegexPattern }).ContainerRateLimitEqualByTime(TravelInfoPanelRouteParam.InputNextManeuverDistanceMin),
					});
		}

 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="chatroomName">Chatroom name.</param>
 /// <param name="bot">Bot reference.</param>
 /// <param name="uiThread">The thread for the currently running UI.</param>
 public UIChat(string chatroomName, Bot bot, dAmnNET dAmn, Thread uiThread)
     : base(chatroomName, bot)
 {
     this.dAmn = dAmn;
     this.UIThread = uiThread;
     Messages = new ObservableCollection<string>();
 }

        public static void cmd_act(Bot bot, String ns, String[] args, String msg, String from, dAmnPacket packet)
        {
            if (args.Length < 2)
            {
                bot.Say(ns, String.Format("<b>&raquo; Usage:</b> {0}act <i>[#channel]</i> msg", bot.Config.Trigger));
            }
            else
            {
                String chan, mesg;

                if (!args[1].StartsWith("#"))
                {
                    chan = ns;
                    mesg = msg.Substring(4);
                }
                else
                {
                    chan = args[1];
                    mesg = msg.Substring(5 + args[1].Length);
                }

                lock (CommandChannels["send"])
                {
                    CommandChannels["send"].Add(ns);
                }

                bot.Act(chan, mesg);
            }
        }

 public void UpdateBot(Bot bot)
 {
     var healthSlider = gameObject.GetComponentInChildren<Slider>();
     healthSlider.minValue = 0;
     healthSlider.maxValue = bot.PhysicalHealth.Maximum;
     healthSlider.value = bot.PhysicalHealth.Current;
 }

		static public ITaskParam Resolve(
			this ShipUndockParam Param,
			Bot Bot)
		{
			var MemoryMeasurement = Bot?.SequenceStepLastState()?.MemoryMeasurement?.Wert;

			if (false == MemoryMeasurement.ShipState()?.Docked())
			{
				return null;
			}

			var WindowStationLobby = MemoryMeasurement.WindowStationLobby?.FirstOrDefault();

			var ButtonUndock = WindowStationLobby?.ButtonUndock;

			if (WindowStationLobby?.UnDocking() ?? false)
			{
				return new ToClientStatusParam("waiting for undock to complete", TaskStatusEnum.WaitingForTransition);
			}

            if (null == ButtonUndock)
			{
				return new ToClientStatusParam("button to undock not available", TaskStatusEnum.Failed);
			}

			return new MouseClickUIElementParam(ButtonUndock, MouseButtonIdEnum.Left);
		}

        public override System.Collections.Generic.IEnumerator<string> Run(Bot bot)
        {
            var r = new Random();
            var chosenCombo = (from combo in bot.getComboList()
                              where
                                  combo.Score > 0 && combo.Type.HasFlag(ComboType.GROUND)
                              orderby combo.Score descending
                              
                              select combo).Take(5);
            if (chosenCombo.Count() == 0)
			{
				_reason = "No combos?";
                yield break;
			}
            var c = chosenCombo.ElementAt(r.Next(chosenCombo.Count()));
            var timer = 0;
            while(Math.Abs(bot.myState.XDistance) > c.XMax || bot.enemyState.ActiveCancelLists.Contains("REVERSAL") || bot.enemyState.ScriptName.Contains("UPWARD"))
            {
                bot.pressButton("6");
                if (timer++ > 10)
				{
					_reason = "Rerolling";
                    yield break;
				}
                
                yield return "Getting in range"+timer;
            }

			var substate = new SequenceState(c.Input);
			while(!substate.isFinished())
				yield return substate.Process(bot);
        }

        public static void cmd_part(Bot bot, String ns, String[] args, String msg, String from, dAmnPacket packet)
        {
            var c = ns;

            if (args.Length != 2)
            {
                // Ignore this for now.
                //bot.Say(ns, String.Format("<b>&raquo; Usage:</b> {0}part #channel", bot.Config.Trigger));
            }
            else
            {
                if (!args[1].StartsWith("#"))
                {
                    bot.Say(ns, "<b>&raquo; Invalid channel!</b> Channels should start with a #");
                    return;
                }

                c = args[1];
            }

            lock (CommandChannels["part"])
            {
                CommandChannels["part"].Add(ns);
            }

            bot.Part(c);
        }

 private static void Main(string[] args)
 {
     using (var bot = new Bot())
     {
         bot.Run();
     }
 }

        public bool IsCommandExecutionAllowed(Command command, Bot bot, string hostMask)
        {
            var users = bot.GetAuthenticatedUsers();
            var user = users.GetUserByHostMask(hostMask);

            return user.SecurityLevel >= (int)command.GetRequiredSecurityLevel();
        }

 public static void cmd_disconnects(Bot bot, String ns, String[] args, String msg, String from, dAmnPacket packet)
 {
     if (Program.Disconnects == 0)
         bot.Say(ns, "<b>&raquo; I have not disconnected since startup.</b>");
     else
         bot.Say(ns, String.Format("<b>&raquo; I have disconnected {0} time{1} since startup.</b>", Program.Disconnects, Program.Disconnects == 1 ? "" : "s"));
 }

 public static void HandleGameEntitiesDispositionMessage(Bot bot, GameEntitiesDispositionMessage message)
 {
     if (!bot.Character.IsFighting())
         logger.Error("Received GameEntitiesDispositionMessage but character is not in fight !");
     else
         bot.Character.Fight.Update(message);
 }

 public static void HandleGameFightHumanReadyStateMessage(Bot bot, GameFightHumanReadyStateMessage message)
 {
     if (!bot.Character.IsFighting())
         logger.Error("Received GameFightHumanReadyStateMessage but character is not in fight !");
     else
         bot.Character.Fight.Update(message);
 }

 public Tell(Bot bot)
     : base(bot)
 {
     Bot.OnChannelMessage+=new IrcEventHandler(Bot_OnMessage);
     Bot.OnQueryMessage += new IrcEventHandler(Bot_OnMessage);
     Bot.OnJoin += new JoinEventHandler(Bot_OnJoin);
 }

        public static void HandleGameMapMovementMessage(Bot bot, GameMapMovementMessage message)
        {
            if (bot.Character.Context == null)
            {
                logger.Error("Context is null as processing movement");
                return;
            }

            var actor = bot.Character.Context.GetContextActor(message.actorId);

            if (actor == null)
                logger.Error("Actor {0} not found", message.actorId); // only a log for the moment until context are fully handled
            else
            {
                var path = Path.BuildFromServerCompressedPath(bot.Character.Map, message.keyMovements);

                if (path.IsEmpty())
                {
                    logger.Warn("Try to start moving with an empty path");
                    return;
                }

                var movement = new MovementBehavior(path, actor.GetAdaptedVelocity(path));
                movement.Start(DateTime.Now + TimeSpan.FromMilliseconds(EstimatedMovementLag));

                actor.NotifyStartMoving(movement);
            }
        }

		static public IEnumerable<ITaskParam> Resolve(
			this ShipModuleActivateParam Param,
			Bot Bot)
		{
			var Module = Param?.Module;
			var Target = Param?.Target;

			if (null != Target)
			{
				var TargetMeasurementLast =
					Bot?.SequenceStepLastState()?.MemoryMeasurement?.Wert?.Target?.FirstOrDefault(Candidate => Candidate?.Id == Target?.Id);

				if (null == TargetMeasurementLast)
				{
					yield return new ToClientStatusParam("requested Target not present", TaskStatusEnum.Failed);
				}

				if (!(TargetMeasurementLast?.Active ?? false))
				{
					yield return new MouseClickUIElementParam(TargetMeasurementLast, BotEngine.Motor.MouseButtonIdEnum.Left);
				}
			}

			//	Sensor Data is noisy and will sometimes report an active module as inactive.
			//	Therefore activation is only attempted when multiple sensor measurements have shown inactivity.
			if (Bot?.SequenceInstantOfAccuEntityReversed(Module)
				?.Take(ShipModuleActivateParam.NoiseSupressionThresholdStepCount)
				?.Any(ModuleInstant => ModuleInstant?.LastInstant?.Wert?.Module?.RampActive ?? false) ?? false)
			{
				//	module was active in the last NoiseSupressionThresholdStepCount steps.
				yield break;
			}

			yield return new ShipModuleActivityToggleParam(Module);
		}

 public override System.Collections.Generic.IEnumerator<string> Run(Bot bot)
 {
     string danceButton = "";
     int danceDuration = 0;
     var rnd = random.NextDouble();
     if (rnd > .9)
     {
         danceButton = "2";
         danceDuration = 1 + random.Next(_maxCrouch);
     }
     else if (rnd > .65 && Math.Abs(bot.myState.XDistance) < _targetDistance)
     {
         danceButton = "4";
         danceDuration = 1 + random.Next(_maxBackward);
     }
     else
     {
         danceButton = "6";
         danceDuration = 1 + random.Next(_maxForward);
     }
     while (danceDuration-- > 0)
     {
         bot.pressButton(danceButton);
         yield return "Dancing";
     }
 }

 public void FriendRun(SteamFriends.FriendMsgCallback callback, Bot bot, object[] args = null)
 {
     List<string> strings = new List<string>(callback.Message.Split(' '));
     strings.RemoveAt(0);
     string company = String.Join(" ", strings.ToArray());
     bot.FriendMessage(callback.Sender, Util.GetYahooStocks(company));
 }