public static void LoadAllQuests(this IBotEngine instance)
{
List <int> ids = new List <int>();
foreach (IBotCommand cmd in instance.Configuration.Commands)
{
switch (cmd)
{
case CmdAcceptQuest caq:
ids.Add(caq.Quest.Id);
break;
case CmdCompleteQuest ccq:
ids.Add(ccq.Quest.Id);
break;
}
}
ids.AddRange(instance.Configuration.Quests.Select(q => q.Id));
if (ids.Count > 0)
{
Player.Quests.Get(ids);
}
}
public async Task Execute(IBotEngine instance)
{
CmdKill kill = new CmdKill {
Monster = Monster
};
if (ItemType == ItemType.Items)
{
while (instance.IsRunning && Player.IsLoggedIn && Player.IsAlive &&
!Player.Inventory.ContainsItem(ItemName, Quantity))
{
await kill.Execute(instance);
await Task.Delay(1000);
}
}
else
{
while (instance.IsRunning && Player.IsLoggedIn && Player.IsAlive &&
!Player.TempInventory.ContainsItem(ItemName, Quantity))
{
await kill.Execute(instance);
await Task.Delay(1000);
}
}
}
public async Task TryJoin(IBotEngine instance, string MapName, string RoomProp = "")
{
fMap = MapName;
//Proxy.Instance.ReceivedFromServer += JsonMapHandler;
if (MapName == "mobius" || MapName == "rangda")
{
Proxy.Instance.ReceivedFromServer += JsonMapHandler;
}
await instance.WaitUntil(() => World.IsActionAvailable(LockActions.Transfer), null, 15);
if (Player.CurrentState == Player.State.InCombat)
{
Player.MoveToCell(Player.Cell, Player.Pad);
await Task.Delay(1250);
}
Player.JoinMap(MapName + RoomProp, this.Cell, this.Pad);
await instance.WaitUntil(() => Player.Map.Equals(MapName, StringComparison.OrdinalIgnoreCase), null, 5);
await instance.WaitUntil(() => !World.IsMapLoading, null, 40);
//Proxy.Instance.ReceivedFromServer -= JsonMapHandler;
if (MapName == "mobius" || MapName == "rangda")
{
await Proxy.Instance.SendToClient(result);
await Task.Delay(500);
}
}
public async Task Execute(IBotEngine instance)
{
if (instance.Configuration.Skills.Count > 0)
{
Task.Run(() => UseSkills(instance));
}
}
public async Task Execute(IBotEngine instance)
{
string path = Path.Combine(Application.StartupPath, BotFileName);
if (File.Exists(path))
{
try
{
string content;
using (TextReader reader = new StreamReader(path))
content = await reader.ReadToEndAsync();
Configuration c = JsonConvert.DeserializeObject <Configuration>(content, new JsonSerializerSettings
{
DefaultValueHandling = DefaultValueHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore,
TypeNameHandling = TypeNameHandling.All
});
if (c?.Commands.Count > 0)
{
instance.Configuration = c;
instance.Index = -1;
instance.LoadBankItems();
instance.LoadAllQuests();
}
}
catch { }
}
}
public static void LoadAllQuests(this IBotEngine instance)
{
List <int> list = new List <int>();
foreach (IBotCommand botCommand in instance.Configuration.Commands)
{
if (botCommand != null)
{
CmdAcceptQuest cmdAcceptQuest;
if ((cmdAcceptQuest = (botCommand as CmdAcceptQuest)) == null)
{
CmdCompleteQuest cmdCompleteQuest;
if ((cmdCompleteQuest = (botCommand as CmdCompleteQuest)) != null)
{
CmdCompleteQuest cmdCompleteQuest2 = cmdCompleteQuest;
list.Add(cmdCompleteQuest2.Quest.Id);
}
}
else
{
CmdAcceptQuest cmdAcceptQuest2 = cmdAcceptQuest;
list.Add(cmdAcceptQuest2.Quest.Id);
}
}
}
list.AddRange(from q in instance.Configuration.Quests
select q.Id);
if (list.Count > 0)
{
Player.Quests.Get(list);
}
}
public static void LoadBankItems(this IBotEngine instance)
{
if (instance.Configuration.Commands.Any((IBotCommand c) => c is CmdBankSwap || c is CmdBankTransfer))
{
Player.Bank.LoadItems();
}
}
public async Task Execute(IBotEngine instance)
{
await instance.WaitUntil(() => World.IsActionAvailable(LockActions.GetMapItem));
Player.GetMapItem(ItemId);
await Task.Delay(2000);
}
public async Task Execute(IBotEngine instance)
{
await instance.WaitUntil(() => World.IsMonsterAvailable(Monster), null, 3);
if (instance.Configuration.WaitForSkills)
{
await instance.WaitUntil(() => Player.AllSkillsAvailable);
}
if (!instance.IsRunning || !Player.IsAlive || !Player.IsLoggedIn)
{
return;
}
Player.AttackMonster(Monster);
if (instance.Configuration.Skills.Count > 0)
{
Task.Run(() => UseSkillsSet(instance));
}
await instance.WaitUntil(() => !Player.HasTarget, null, 360);
Player.CancelTarget();
_cts?.Cancel(false);
}
public async Task Execute(IBotEngine instance)
{
await instance.WaitUntil(() => World.IsActionAvailable(LockActions.BuyItem));
Shop.ResetShopInfo();
Shop.Load(ShopId);
await instance.WaitUntil(() => Shop.IsShopLoaded);
InventoryItem i =
Player.Inventory.Items.FirstOrDefault(
item => item.Name.Equals(ItemName, StringComparison.OrdinalIgnoreCase));
if (i != null)
{
Shop.BuyItem(ItemName);
await instance.WaitUntil(() => Player.Inventory.Items
.FirstOrDefault(it => it.Name.Equals(ItemName,
StringComparison.OrdinalIgnoreCase))
.Quantity != i.Quantity);
}
else
{
Shop.BuyItem(ItemName);
await instance.WaitUntil(
() => Player.Inventory.Items.FirstOrDefault(
it => it.Name.Equals(ItemName, StringComparison.OrdinalIgnoreCase)) != null);
}
}
public async Task Execute(IBotEngine instance)
{
for (int i = 1; i <= SpamTimes; i++)
{
if (!instance.IsRunning || !Player.IsLoggedIn)
{
break;
}
if (ForClient)
{
string packet = Packet;
if (packet.Split(' ')[0] == "Level")
{
packet = "{\"t\":\"xt\",\"b\":{\"r\":-1,\"o\":{\"cmd\":\"levelUp\",\"intExpToLevel\":\"200000\",\"intLevel\":" + packet.Split(' ')[1] + "}}}";
}
await Proxy.Instance.SendToClient(packet);
await Task.Delay(Delay);
}
else
{
await Proxy.Instance.SendToServer(Packet);
await Task.Delay(Delay);
}
}
}
public async Task Execute(IBotEngine instance)
{
await instance.WaitUntil(() => World.IsActionAvailable(LockActions.Transfer));
string cmdMap = Map.Contains("-") ? Map.Split('-')[0] : Map;
string curMap = Player.Map;
if (!cmdMap.Equals(curMap, StringComparison.OrdinalIgnoreCase))
{
await instance.WaitUntil(() => World.IsActionAvailable(LockActions.Transfer));
if (Player.CurrentState == Player.State.InCombat)
{
Player.MoveToCell(Player.Cell, Player.Pad);
await instance.WaitUntil(() => Player.CurrentState == Player.State.InCombat);
}
Player.JoinMap(Map, Cell, Pad);
await instance.WaitUntil(() => Player.Map.Equals(cmdMap, StringComparison.OrdinalIgnoreCase));
await instance.WaitUntil(() => !World.IsMapLoading, null, 40);
if (!Player.Cell.Equals(Cell, StringComparison.OrdinalIgnoreCase))
{
Player.MoveToCell(Cell, Pad);
await Task.Delay(500);
}
}
}
public Task Execute(IBotEngine instance)
{
switch (Type)
{
case IndexCommand.Down:
int down = Index - 1;
if (down > 0)
{
int check = instance.Index += down;
if (check < instance.Configuration.Commands.Count)
{
instance.Index = check;
}
}
break;
case IndexCommand.Up:
int up = Index + 1;
if (up > 0)
{
int check = instance.Index -= up;
if (check > -1)
{
instance.Index = check;
}
}
break;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (World.VisibleMonsters.Count >= int.Parse(Value1))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (Player.CurrentState == Player.State.InCombat)
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (Value1.Equals(Player.Cell, StringComparison.OrdinalIgnoreCase))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (Player.Quests.IsInProgress(int.Parse(Value1)))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (World.DropStack.Contains(Value1))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (World.PlayersInMap.Count <= int.Parse(Value1))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (!Player.Quests.CanComplete(int.Parse(Value1)))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (Player.Gold >= int.Parse(Value1))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (World.IsMonsterAvailable(Value1))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public Task Execute(IBotEngine instance)
{
if (Player.Bank.ContainsItem(Value1, Value2))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public async Task Execute(IBotEngine instance)
{
if (ItemType == ItemType.Items)
{
if (Player.Inventory.ContainsItem(ItemName, Quantity))
{
return;
}
}
else
{
if (Player.TempInventory.ContainsItem(ItemName, Quantity))
{
return;
}
}
if (!Player.Map.Equals(Map.Split('-')[0]))
{
CmdJoin join = new CmdJoin
{
Map = this.Map,
Cell = this.Cell,
Pad = this.Pad
};
if (BlankFirst)
{
Player.MoveToCell("Blank", "Left");
await Task.Delay(1000);
}
await join.Execute(instance);
}
else
{
Player.MoveToCell(Cell, Pad);
}
await Task.Delay(1000);
CmdKillFor killFor = new CmdKillFor
{
Monster = this.Monster,
MonId = this.MonId,
ItemName = this.ItemName,
ItemType = this.ItemType,
Quantity = this.Quantity,
IsGetDrops = this.IsGetDrops,
AfterKills = this.AfterKills,
QuestId = this.QuestId,
DelayAfterKill = this.DelayAfterKill,
};
await killFor.Execute(instance);
await Task.Delay(1000);
}
public async Task Execute(IBotEngine instance)
{
Player.WalkToPoint(X, Y);
await instance.WaitUntil(() =>
{
float[] pos = Player.Position;
return(pos[0].ToString() == X && pos[1].ToString() == Y);
});
}
public Task Execute(IBotEngine instance)
{
if (World.PlayersInMap.FirstOrDefault(
p => p.Equals(Value1, StringComparison.OrdinalIgnoreCase)) != null)
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public async Task Execute(IBotEngine instance)
{
await instance.WaitUntil(() => Player.Quests.QuestTree.Any(q => q.Id == Quest.Id));
await instance.WaitUntil(() => World.IsActionAvailable(LockActions.AcceptQuest));
Quest.Accept();
await instance.WaitUntil(() => Player.Quests.IsInProgress(Quest.Id));
}
public async Task Execute(IBotEngine instance)
{
bool CanExecute() => Player.Bank.ContainsItem(BankItemName) && Player.Inventory.ContainsItem(InventoryItemName, "*");
if (CanExecute())
{
Player.Bank.Swap(InventoryItemName, BankItemName);
await instance.WaitUntil(() => !CanExecute());
}
}
public Task Execute(IBotEngine instance)
{
string map = Value1.Contains("-") ?
Value1.Split('-')[0] : Value1;
if (!map.Equals(Player.Map, StringComparison.OrdinalIgnoreCase))
{
instance.Index++;
}
return(Task.FromResult <object>(null));
}
public async Task Execute(IBotEngine instance)
{
for (int i = 0; i < 10; i++)
{
Console.Beep();
}
if (PopMsg)
{
MessageBox.Show($"Your ping !");
}
}
public MainWindow()
{
InitializeComponent();
this.Text = this.Text + " - Wersja " + Application.ProductVersion.ToString();
this.random = new Random();
this.dbg = new DebugWindow();
this.btnShowDebugWindow_Click(null, null);
this.pawn_matrix = new PawnType[8, 8];
this.field_matrix = new Label[8, 8];
this.selected_color_matrix = new Color[8, 8];
this.normal_color_matrix = new Color[8, 8];
this.selected_field = PointExt.Invalid;
for (int r = 0; r < 8; r++)
for (int c = 0; c < 8; c++)
{
string cname = string.Format("p{0}{1}", (char)('A' + r), 1 + c);
this.field_matrix[r, c] = this.panel1.Controls[cname] as Label;
this.normal_color_matrix[r, c] = (r + c) % 2 == 0 ? Color.White : Color.Silver;
this.selected_color_matrix[r, c] = (r + c) % 2 == 0 ? Color.FromArgb(255 - 50, 255, 255 - 50) : Color.FromArgb(192 - 50, 192, 192 - 50);
this.field_matrix[r, c].BackColor = this.normal_color_matrix[r, c];
}
this.current_turn = PawnColor.None;
this.cpu_color = PawnColor.None;
this.human_color = PawnColor.None;
this.ShowGameState();
// uruchomienie bota
this.bot = new MojBot();
this.lblBotAuthor.Text = this.bot.GetAuthor();
this.lblBotDescription.Text = this.bot.GetDescripion();
try
{
this.bot.Initialize();
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Wyjątek podczas uruchamiania metody Bot.Initialize():\n{0}", ex.Message),
Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
