Learn form an old bot :)

[Thelovefool]

Hello Community,
since i used to learn c# i am interested in writing a bot.
But i know from the past that it can be really hard to start something without a source which help you a bit.

The WoW!Sharp code helped me a lot to understand how bots work and how they are written. I know this bot is very outdated and have a lot of coding no gos but where you find another complete bot source?

You can download all files here: WoWSharp.NET: Home

I take no credits for this

Btw dont say this is crap i know many bots which are a makeover of wow!sharp and still work now

[~OddBall~]

Maybe take a look at babbot, it's an open-source bot that is working and being developed currently.

[Cypher]

Just because something works doesn't mean its not a piece of crap. The two aren't mutually exclusive. Take WoWMimic for example, it 'works', and its a piece of crap.

Where was I? Ah yes...

WoW!Sharp is crap. There's more than enough new content to get you started on a bot, there's no need to dig up crap like this.

[xpcpro]

the files have virus DONT DOWNLOAD THEM!

[naa]

the files have virus DONT DOWNLOAD THEM!

And you sir should not post in the section.......

[paradoxial]

And you sir should not post in the section.......

get on MSN more Naa!

[Sychotix]

Its not that hard starting a bot on your own. The hardest part is the movement, which there is plenty of information in this section on how to use CTM

[Robske]

Its not that hard starting a bot on your own. The hardest part is the movement, which there is plenty of information in this section on how to use CTM

I beg to differ.

[Apoc]

Movement is actually the easiest part of a bot. Making it look good however is a different story.

The hardest part is the logic. Any competent bot developer will agree.

[amadmonk]

Movement is actually the easiest part of a bot. Making it look good however is a different story.

The hardest part is the logic. Any competent bot developer will agree.

Hmm, movement has been a huge thorn in my side. I mean simple movement, no. Just "move in a straight line" stuff, that's trivial. But more complicated stuff, pathfinding, obstacle avoidance, that's been something that's big enough that I haven't even bothered to tackle it. The fact that triple-A game shops still have problems with pathfinding tells me that my little hacking skills aren't going to have a breakthrough anytime soon.

Logic... hmm, yeah, that's tougher. If I had a piece of advice for anyone on bot logic, it would be "don't overengineer it." I've gone through about ten different complete iterations on my bot(s), four or five development languages (C#, chunks of managed and non-managed C++, Lua, Python, even a brief flirtation with F#), and several total architectural rewrites. And after all my investigations of behavior trees and whatnot, what I'm finding works best is just a big ol priority list of "things I want to do now, sorted by importance." It doesn't make for PERFECT behavior, but it is, in most cases, at least on par with a human in terms of judgement -- remember that this is WoW... not a terribly complex game. Almost all fights are mashing the same buttons over and over in the same sequence.

So, start by designing the simplest thing that works, and see if that is good enough. You might just be surprised by how effective it is.

[EmilyStrange]

"Keep it simple stupid."

Before Wrath, before Burning Crusade, I coded an effective bot entirely in Lua, that was just an add-on, with waypoint navigation, healing and attacking and looting. The hardest part was figuring out how to make the player turn and move once Blizzard released the patch that prevented me from moving with just script commands. The easiest solution? A heavy book on my keyboard.

Now my "bot", written in C#, uses multilevel goals for party and player, evaluators, behaviours and state machines, and trend lines using exponential mean average for calculating optimal healing patterns, and I don't think it would be any more effective than a simple combat loop and waypoint navigation system.

[amadmonk]

Indeed. I considered working out running averages on health and health declines in order to determine who to heal, and I found that "just heal whoever is most hurt" was totally effective enough (at least for 5-man heroics).

[EmilyStrange]

I found that the slope of the line of the exponential moving average with a five second window was the most effective, for me, in a group of five paladins. It allows for graceful handling of the dip that occurs when the DPS accidentally pulls aggro off the tank, or even a healer, with reasonably quick recovery so that the stochastic noise of a few mobs dropping aggro for a couple of hits doesn't overwhelm the healing function and keeps the concentration on the tank, where it should be.

But I am always interested in how other people handle the healing algorithm.

[Apoc]

Indeed. I considered working out running averages on health and health declines in order to determine who to heal, and I found that "just heal whoever is most hurt" was totally effective enough (at least for 5-man heroics).

Even things like that are incredibly simple to code.

Here's the DpsMeter I wrote a few days ago; basically shows global DPS on all nearby units (easily adapted to your API). Works great for detecting *MUST HEAL NOW* type situations; also works great for spell selections. (So you don't go trying to cast a 5s cast spell; with only 2s left in combat!)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

using Onyx.WoW;
using Onyx.WoW.Objects;

namespace Durid
{
    /// <summary>
    /// Calculates DPS, and combat time left on nearby mobs in combat.
    /// DPS is not calculated as YOUR DPS. But instead; global DPS on the mob. (You and your buddies combined DPS on a single mob)
    /// </summary>
    internal class DpsMeter
    {
        private static readonly Dictionary<ulong, DpsInfo> DpsInfos = new Dictionary<ulong, DpsInfo>();
        private static bool _initialized;
        /// <summary>
        /// Starts the DpsMeter.
        /// </summary>
        public static void Initialize()
        {
            if (!_initialized)
            {
                OnyxWoW.OnFrame += Update;
                DpsInfos.Clear();
                _initialized = true;
            }
        }

        public static void Shutdown()
        {
            if (_initialized)
            {
                OnyxWoW.OnFrame -= Update;
                DpsInfos.Clear();
                _initialized = false;
            }
        }

        private static void Update()
        {
            List<WoWUnit> availableUnits = (from o in OnyxWoW.ObjectList
                                            let otype = o.Type
                                            where otype == WoWObjectType.Unit || otype == WoWObjectType.Player
                                            let u = o.ToUnit()
                                            where !u.Dead && // Bring out yer dead!
                                                  u.Attackable && // Optional. Remove this to include 'friendly npcs'
                                                  u != OnyxWoW.Me && // Lets not include ourselves shall we?
                                                  u.Relation <= WoWUnitRelation.Neutral && // Neutral -> Hated
                                                  u.InCombat // Only consider in combat units
                                            orderby u.Distance ascending // Not really needed; just used for brevity [you know the higher index; the further away they are]
                                            select u).ToList();

            foreach (WoWUnit unit in availableUnits)
            {
                if (!DpsInfos.ContainsKey(unit.Guid))
                {
                    var di = new DpsInfo
                                     {
                                         Unit = unit,
                                         CombatStart = DateTime.Now,
                                         StartHealth = unit.CurrentHealth
                                     };

                    DpsInfos.Add(unit.Guid, di);
                }
                else
                {
                    DpsInfo di = DpsInfos[unit.Guid];

                    di.CurrentDps = (di.StartHealth - unit.CurrentHealth) / (DateTime.Now - di.CombatStart).TotalSeconds;
                    di.CombatTimeLeft = new TimeSpan(0, 0, (int) (unit.CurrentHealth / di.CurrentDps));

                    // .NET makes a copy of the struct when we grab it out of the collection.
                    // Make sure we put the updated version back in!
                    DpsInfos[unit.Guid] = di;
                }
            }

            // Kill off any 'bad' units in our list.
            KeyValuePair<ulong, DpsInfo>[] removeUnits = DpsInfos.Where(kv => !kv.Value.Unit.IsValid).ToArray();
            for (int i = 0; i < removeUnits.Length; i++)
            {
                DpsInfos.Remove(removeUnits[i].Key);
            }
        }

        /// <summary>
        /// Returns the current DPS on a specific unit, or -1 if the unit is not currently being tracked, or doesn't exist.
        /// </summary>
        /// <param name="u"></param>
        /// <returns></returns>
        public static double GetDps(WoWUnit u)
        {
            if (DpsInfos.ContainsKey(u.Guid))
            {
                return DpsInfos[u.Guid].CurrentDps;
            }
            // -1 is a fail case.
            return -1;
        }

        /// <summary>
        /// Returns the estimated combat time left for this unit. (Time until death)
        /// If the unit is invalid; TimeSpan.MinValue is returned.
        /// </summary>
        /// <param name="u"></param>
        /// <returns></returns>
        public static TimeSpan GetCombatTimeLeft(WoWUnit u)
        {
            if (DpsInfos.ContainsKey(u.Guid))
            {
                return DpsInfos[u.Guid].CombatTimeLeft;
            }
            return TimeSpan.MinValue;
        }

        #region Nested type: DpsInfo

        private struct DpsInfo
        {
            public DateTime CombatStart;
            public TimeSpan CombatTimeLeft;
            public double CurrentDps;
            public uint StartHealth;
            public WoWUnit Unit;
        }

        #endregion
    }
}

It's simple, self updating, and fast. (Plus; way more accurate than what you get from parsing combat log events!)