Doubt with BackgroundWorker

[Tabgyn]

I have the following scenario: two Backgroundworker, one for cavebot (Walker) and the other for targeting. I did so to have the option of working with the two functions independently. can enable only the cavebot, only targeting or both simultaneously.

My question is: How do I pause or stop the execution of cavebot through a call from targeting?

Or what would be the best method to have two different methods running simultaneously, but still depended on one another.

Sorry for the google translator...

[Blaster_89]

How about running both on one thread?

[Tabgyn]

Running separately

[Blaster_89]

Running separately

I know they do, and running the code one a single thread would solve your issue
If you insist on using 2 BackgroundWorkers, post the code relevant to your BackgroundWorker objects

[Tabgyn]

You say the two BackgroundWorker run in one thread?

My two BackgroundWorker:

[code=csharp]
public class Walker
{
private readonly Client _client = Program.MyClient;
private readonly BackgroundWorker _walkerThread = new BackgroundWorker();
private List<Waypoint> _wpList = new List<Waypoint>();

public Walker()
{
_walkerThread.DoWork += WalkerExecute;
_walkerThread.WorkerSupportsCancellation = true;
}

private void WalkerExecute(object sender, DoWorkEventArgs e)
{
_wpList = (List<Waypoint>)e.Argument;
var _player = _client.GetPlayer();

while (true)
{
Thread.Sleep(100);

if (!_client.LoggedIn || e.Cancel) return;

foreach (var _waypoint in _wpList)
{
_player.GoTo = _waypoint.Location;
}

if (!_walkerThread.CancellationPending) continue;
e.Cancel = true;
return;
}
}

public bool IsRunning()
{
return _walkerThread.IsBusy;
}

public void Start(List<Waypoint> waypoints)
{
_walkerThread.RunWorkerAsync(waypoints);
}

public void Stop()
{
_walkerThread.CancelAsync();
}
}
[/code]

[code=csharp]
public class Target
{
private readonly Client _client = Program.MyClient;
public BackgroundWorker TargetThread = new BackgroundWorker();

public Target()
{
TargetThread.DoWork += TargetExecute;
TargetThread.WorkerSupportsCancellation = true;
}

private void TargetExecute(object sender, DoWorkEventArgs e)
{
var _targetList = (List<TargetObject>) e.Argument;
var _player = _client.GetPlayer();
while (true)
{
try
{
if(_player.Target_ID == 0)
{
var _creature = _client.BattleList.GetCreatures().FirstOrDefault(c => !c.IsSelf() && c.IsReachable() && c.DistanceTo(_player.Location) < 10);
if (!(_creature == null))
{
foreach (var _t in _targetList)
{
if(_creature.Name.ToLower() == _t.Name.ToLower())
{
_player.Stop();
_creature.Attack();
}
}
}
}

Thread.Sleep(100);
}
catch (Exception)
{
return;
}
}
}

public bool IsRunning()
{
return TargetThread.IsBusy;
}

public void Start(List<TargetObject> targetList)
{
TargetThread.RunWorkerAsync(targetList);
}

public void Stop()
{
TargetThread.CancelAsync();
}
}
[/code]

I want him to stop walking if it's attacking.
And walk again after that

[Blaster_89]

First off, you need to optimize your code.
Your walker will walk to a different waypoint every 0.1 seconds, which it shouldn't.
Your targetting is also horribly ineffective, it's much better to first get a list of creatures that match the names of which you want to attack, THEN find out if they are close enough and reachable.

If you want to keep it simple and not having to dabble with cancelling threads left and right, put both targetting and walking in a single dedicated thread (or a BackgroundWorker, they're pretty much the same) and use some boolean variables to determine what the thread should do (i.e. player is currently killing something so don't walk, or player is not walking and no targets in sight, go to waypoint)

[Tabgyn]

The code snippets are just for testing so far.
I will study your suggestion to place within the same thread.