mirror of
https://github.com/MCCTeam/Minecraft-Console-Client
synced 2025-10-14 21:22:49 +00:00
787 lines
29 KiB
C#
787 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using MinecraftClient.Inventory;
|
|
using MinecraftClient.Mapping;
|
|
using Tomlet.Attributes;
|
|
|
|
namespace MinecraftClient.ChatBots
|
|
{
|
|
public class AutoCraft : ChatBot
|
|
{
|
|
public static Configs Config = new();
|
|
|
|
[TomlDoNotInlineObject]
|
|
public class Configs
|
|
{
|
|
[NonSerialized]
|
|
private const string BotName = "AutoCraft";
|
|
|
|
public bool Enabled = false;
|
|
|
|
public string configFile = @"autocraft\config.ini";
|
|
|
|
public void OnSettingUpdate() { }
|
|
}
|
|
|
|
private bool waitingForMaterials = false;
|
|
private bool waitingForUpdate = false;
|
|
private bool waitingForTable = false;
|
|
private bool craftingFailed = false;
|
|
private int inventoryInUse = -2;
|
|
private int index = 0;
|
|
private Recipe? recipeInUse;
|
|
private readonly List<ActionStep> actionSteps = new();
|
|
|
|
private Location tableLocation = new();
|
|
private bool abortOnFailure = true;
|
|
private int updateDebounceValue = 2;
|
|
private int updateDebounce = 0;
|
|
private readonly int updateTimeoutValue = 10;
|
|
private int updateTimeout = 0;
|
|
private string timeoutAction = "unspecified";
|
|
|
|
private string lastRecipe = ""; // Used in parsing recipe config
|
|
|
|
private readonly Dictionary<string, Recipe> recipes = new();
|
|
|
|
private void ResetVar()
|
|
{
|
|
craftingFailed = false;
|
|
waitingForTable = false;
|
|
waitingForUpdate = false;
|
|
waitingForMaterials = false;
|
|
inventoryInUse = -2;
|
|
index = 0;
|
|
recipeInUse = null;
|
|
actionSteps.Clear();
|
|
}
|
|
|
|
private enum ActionType
|
|
{
|
|
LeftClick,
|
|
ShiftClick,
|
|
WaitForUpdate,
|
|
ResetCraftArea,
|
|
Repeat,
|
|
CheckResult
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represent a single action step of the whole crafting process
|
|
/// </summary>
|
|
private class ActionStep
|
|
{
|
|
/// <summary>
|
|
/// The action type of this action step
|
|
/// </summary>
|
|
public ActionType ActionType;
|
|
|
|
/// <summary>
|
|
/// For storing data needed for processing
|
|
/// </summary>
|
|
/// <remarks>-2 mean not used</remarks>
|
|
public int Slot = -2;
|
|
|
|
/// <summary>
|
|
/// For storing data needed for processing
|
|
/// </summary>
|
|
/// <remarks>-2 mean not used</remarks>
|
|
public int InventoryID = -2;
|
|
|
|
/// <summary>
|
|
/// For storing data needed for processing
|
|
/// </summary>
|
|
public ItemType ItemType;
|
|
|
|
public ActionStep(ActionType actionType)
|
|
{
|
|
ActionType = actionType;
|
|
}
|
|
public ActionStep(ActionType actionType, int inventoryID)
|
|
{
|
|
ActionType = actionType;
|
|
InventoryID = inventoryID;
|
|
}
|
|
public ActionStep(ActionType actionType, int inventoryID, int slot)
|
|
{
|
|
ActionType = actionType;
|
|
Slot = slot;
|
|
InventoryID = inventoryID;
|
|
}
|
|
public ActionStep(ActionType actionType, int inventoryID, ItemType itemType)
|
|
{
|
|
ActionType = actionType;
|
|
InventoryID = inventoryID;
|
|
ItemType = itemType;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represent a crafting recipe
|
|
/// </summary>
|
|
private class Recipe
|
|
{
|
|
/// <summary>
|
|
/// The results item of this recipe
|
|
/// </summary>
|
|
public ItemType ResultItem;
|
|
|
|
/// <summary>
|
|
/// Crafting table required for this recipe, playerInventory or Crafting
|
|
/// </summary>
|
|
public ContainerType CraftingAreaType;
|
|
|
|
/// <summary>
|
|
/// Materials needed and their position
|
|
/// </summary>
|
|
/// <remarks>position start with 1, from left to right, top to bottom</remarks>
|
|
public Dictionary<int, ItemType>? Materials;
|
|
|
|
public Recipe() { }
|
|
|
|
public Recipe(Dictionary<int, ItemType> materials, ItemType resultItem, ContainerType type)
|
|
{
|
|
Materials = materials;
|
|
ResultItem = resultItem;
|
|
CraftingAreaType = type;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert the position of a defined recipe from playerInventory to Crafting
|
|
/// </summary>
|
|
/// <param name="recipe"></param>
|
|
/// <returns>Converted recipe</returns>
|
|
/// <remarks>so that it can be used in crafting table</remarks>
|
|
public static Recipe ConvertToCraftingTable(Recipe recipe)
|
|
{
|
|
if (recipe.CraftingAreaType == ContainerType.PlayerInventory && recipe.Materials != null)
|
|
{
|
|
if (recipe.Materials.ContainsKey(4))
|
|
{
|
|
recipe.Materials[5] = recipe.Materials[4];
|
|
recipe.Materials.Remove(4);
|
|
}
|
|
if (recipe.Materials.ContainsKey(3))
|
|
{
|
|
recipe.Materials[4] = recipe.Materials[3];
|
|
recipe.Materials.Remove(3);
|
|
}
|
|
}
|
|
return recipe;
|
|
}
|
|
}
|
|
|
|
public override void Initialize()
|
|
{
|
|
if (!GetInventoryEnabled())
|
|
{
|
|
LogToConsoleTranslated("extra.inventory_required");
|
|
LogToConsoleTranslated("general.bot_unload");
|
|
UnloadBot();
|
|
return;
|
|
}
|
|
RegisterChatBotCommand("autocraft", Translations.Get("bot.autoCraft.cmd"), GetHelp(), CommandHandler);
|
|
RegisterChatBotCommand("ac", Translations.Get("bot.autoCraft.alias"), GetHelp(), CommandHandler);
|
|
LoadConfig();
|
|
}
|
|
|
|
public string CommandHandler(string cmd, string[] args)
|
|
{
|
|
if (args.Length > 0)
|
|
{
|
|
switch (args[0])
|
|
{
|
|
case "load":
|
|
LoadConfig();
|
|
return "";
|
|
case "list":
|
|
string names = string.Join(", ", recipes.Keys.ToList());
|
|
return Translations.Get("bot.autoCraft.cmd.list", recipes.Count, names);
|
|
case "reload":
|
|
recipes.Clear();
|
|
LoadConfig();
|
|
return "";
|
|
case "resetcfg":
|
|
WriteDefaultConfig();
|
|
return Translations.Get("bot.autoCraft.cmd.resetcfg");
|
|
case "start":
|
|
if (args.Length >= 2)
|
|
{
|
|
string name = args[1];
|
|
if (recipes.ContainsKey(name))
|
|
{
|
|
ResetVar();
|
|
PrepareCrafting(recipes[name]);
|
|
return "";
|
|
}
|
|
else return Translations.Get("bot.autoCraft.recipe_not_exist");
|
|
}
|
|
else return Translations.Get("bot.autoCraft.no_recipe_name");
|
|
case "stop":
|
|
StopCrafting();
|
|
return Translations.Get("bot.autoCraft.stop");
|
|
case "help":
|
|
return GetCommandHelp(args.Length >= 2 ? args[1] : "");
|
|
default:
|
|
return GetHelp();
|
|
}
|
|
}
|
|
else return GetHelp();
|
|
}
|
|
|
|
private static string GetHelp()
|
|
{
|
|
return Translations.Get("bot.autoCraft.available_cmd", "load, list, reload, resetcfg, start, stop, help");
|
|
}
|
|
|
|
private string GetCommandHelp(string cmd)
|
|
{
|
|
return cmd.ToLower() switch
|
|
{
|
|
#pragma warning disable format // @formatter:off
|
|
"load" => Translations.Get("bot.autocraft.help.load"),
|
|
"list" => Translations.Get("bot.autocraft.help.list"),
|
|
"reload" => Translations.Get("bot.autocraft.help.reload"),
|
|
"resetcfg" => Translations.Get("bot.autocraft.help.resetcfg"),
|
|
"start" => Translations.Get("bot.autocraft.help.start"),
|
|
"stop" => Translations.Get("bot.autocraft.help.stop"),
|
|
"help" => Translations.Get("bot.autocraft.help.help"),
|
|
_ => GetHelp(),
|
|
#pragma warning restore format // @formatter:on
|
|
};
|
|
}
|
|
|
|
#region Config handling
|
|
|
|
public void LoadConfig()
|
|
{
|
|
if (!File.Exists(Config.configFile))
|
|
{
|
|
if (!Directory.Exists(Config.configFile))
|
|
{
|
|
Directory.CreateDirectory(@"autocraft");
|
|
}
|
|
WriteDefaultConfig();
|
|
LogDebugToConsoleTranslated("bot.autoCraft.debug.no_config");
|
|
}
|
|
try
|
|
{
|
|
ParseConfig();
|
|
LogToConsoleTranslated("bot.autoCraft.loaded");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
LogToConsoleTranslated("bot.autoCraft.error.config", "\n" + e.Message);
|
|
}
|
|
}
|
|
|
|
private void WriteDefaultConfig()
|
|
{
|
|
string[] content =
|
|
{
|
|
"[AutoCraft]",
|
|
"# A valid autocraft config must begin with [AutoCraft]",
|
|
"",
|
|
"tablelocation=0,65,0 # Location of the crafting table if you intended to use it. Terrain and movements must be enabled. Format: x,y,z",
|
|
"onfailure=abort # What to do on crafting failure, abort or wait",
|
|
"",
|
|
"# You can define multiple recipes in a single config file",
|
|
"# This is an example of how to define a recipe",
|
|
"[Recipe]",
|
|
"name=whatever # name could be whatever you like. This field must be defined first",
|
|
"type=player # crafting table type: player or table",
|
|
"result=StoneButton # the resulting item",
|
|
"",
|
|
"# define slots with their deserved item",
|
|
"slot1=Stone # slot start with 1, count from left to right, top to bottom",
|
|
"# For the naming of the items, please see",
|
|
"# https://github.com/MCCTeam/Minecraft-Console-Client/blob/master/MinecraftClient/Inventory/ItemType.cs"
|
|
};
|
|
File.WriteAllLines(Config.configFile, content);
|
|
}
|
|
|
|
private void ParseConfig()
|
|
{
|
|
string[] content = File.ReadAllLines(Config.configFile);
|
|
if (content.Length <= 0)
|
|
{
|
|
throw new Exception(Translations.Get("bot.autoCraft.exception.empty", Config.configFile));
|
|
}
|
|
if (content[0].ToLower() != "[autocraft]")
|
|
{
|
|
throw new Exception(Translations.Get("bot.autoCraft.exception.invalid", Config.configFile));
|
|
}
|
|
|
|
// local variable for use in parsing config
|
|
string section = "";
|
|
Dictionary<string, Recipe> recipes = new();
|
|
|
|
foreach (string l in content)
|
|
{
|
|
// ignore comment start with #
|
|
if (l.StartsWith("#"))
|
|
continue;
|
|
string line = l.Split('#')[0].Trim();
|
|
if (line.Length <= 0)
|
|
continue;
|
|
|
|
if (line[0] == '[' && line[^1] == ']')
|
|
{
|
|
section = line[1..^1].ToLower();
|
|
continue;
|
|
}
|
|
|
|
string key = line.Split('=')[0].ToLower();
|
|
if (!(line.Length > (key.Length + 1)))
|
|
continue;
|
|
string value = line[(key.Length + 1)..];
|
|
switch (section)
|
|
{
|
|
case "recipe": ParseRecipe(key, value); break;
|
|
case "autocraft": ParseMain(key, value); break;
|
|
}
|
|
}
|
|
|
|
// check and save recipe
|
|
foreach (var pair in recipes)
|
|
{
|
|
if ((pair.Value.CraftingAreaType == ContainerType.PlayerInventory
|
|
|| pair.Value.CraftingAreaType == ContainerType.Crafting)
|
|
&& (pair.Value.Materials != null
|
|
&& pair.Value.Materials.Count > 0)
|
|
&& pair.Value.ResultItem != ItemType.Air)
|
|
{
|
|
// checking pass
|
|
this.recipes.Add(pair.Key, pair.Value);
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(Translations.Get("bot.autoCraft.exception.item_miss", pair.Key));
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
#region Method for parsing different section of config
|
|
|
|
private void ParseMain(string key, string value)
|
|
{
|
|
switch (key)
|
|
{
|
|
case "tablelocation":
|
|
string[] values = value.Split(',');
|
|
if (values.Length == 3)
|
|
{
|
|
tableLocation.X = Convert.ToInt32(values[0]);
|
|
tableLocation.Y = Convert.ToInt32(values[1]);
|
|
tableLocation.Z = Convert.ToInt32(values[2]);
|
|
}
|
|
else throw new Exception(Translations.Get("bot.autoCraft.exception.invalid_table", key));
|
|
break;
|
|
case "onfailure":
|
|
abortOnFailure = value.ToLower() == "abort";
|
|
break;
|
|
case "updatedebounce":
|
|
updateDebounceValue = Convert.ToInt32(value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void ParseRecipe(string key, string value)
|
|
{
|
|
if (key.StartsWith("slot"))
|
|
{
|
|
int slot = Convert.ToInt32(key[^1].ToString());
|
|
if (slot > 0 && slot < 10)
|
|
{
|
|
if (recipes.ContainsKey(lastRecipe))
|
|
{
|
|
if (Enum.TryParse(value, true, out ItemType itemType))
|
|
{
|
|
Dictionary<int, ItemType>? materials = recipes[lastRecipe].Materials;
|
|
if (materials != null && materials.Count > 0)
|
|
{
|
|
materials.Add(slot, itemType);
|
|
}
|
|
else
|
|
{
|
|
recipes[lastRecipe].Materials = new Dictionary<int, ItemType>()
|
|
{
|
|
{ slot, itemType }
|
|
};
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(Translations.Get("bot.autoCraft.exception.item_name", lastRecipe, key));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(Translations.Get("bot.autoCraft.exception.name_miss"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(Translations.Get("bot.autoCraft.exception.slot", key));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (key)
|
|
{
|
|
case "name":
|
|
if (!recipes.ContainsKey(value))
|
|
{
|
|
recipes.Add(value, new Recipe());
|
|
lastRecipe = value;
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(Translations.Get("bot.autoCraft.exception.duplicate", value));
|
|
}
|
|
break;
|
|
case "type":
|
|
if (recipes.ContainsKey(lastRecipe))
|
|
{
|
|
recipes[lastRecipe].CraftingAreaType = value.ToLower() == "player" ? ContainerType.PlayerInventory : ContainerType.Crafting;
|
|
}
|
|
break;
|
|
case "result":
|
|
if (recipes.ContainsKey(lastRecipe))
|
|
{
|
|
if (Enum.TryParse(value, true, out ItemType itemType))
|
|
{
|
|
recipes[lastRecipe].ResultItem = itemType;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Core part of auto-crafting
|
|
|
|
public override void OnInventoryUpdate(int inventoryId)
|
|
{
|
|
if ((waitingForUpdate && inventoryInUse == inventoryId) || (waitingForMaterials && inventoryInUse == inventoryId))
|
|
{
|
|
// Because server might send us a LOT of update at once, even there is only a single slot updated.
|
|
// Using this to make sure we don't do things before inventory update finish
|
|
updateDebounce = updateDebounceValue;
|
|
}
|
|
}
|
|
|
|
public override void OnInventoryOpen(int inventoryId)
|
|
{
|
|
if (waitingForTable)
|
|
{
|
|
if (GetInventories()[inventoryId].Type == ContainerType.Crafting)
|
|
{
|
|
waitingForTable = false;
|
|
ClearTimeout();
|
|
// After table opened, we need to wait for server to update table inventory items
|
|
waitingForUpdate = true;
|
|
inventoryInUse = inventoryId;
|
|
PrepareCrafting(recipeInUse!);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Update()
|
|
{
|
|
if (updateDebounce > 0)
|
|
{
|
|
updateDebounce--;
|
|
if (updateDebounce <= 0)
|
|
InventoryUpdateFinished();
|
|
}
|
|
if (updateTimeout > 0)
|
|
{
|
|
updateTimeout--;
|
|
if (updateTimeout <= 0)
|
|
HandleUpdateTimeout();
|
|
}
|
|
}
|
|
|
|
private void InventoryUpdateFinished()
|
|
{
|
|
if (waitingForUpdate || waitingForMaterials)
|
|
{
|
|
if (waitingForUpdate)
|
|
waitingForUpdate = false;
|
|
if (waitingForMaterials)
|
|
{
|
|
waitingForMaterials = false;
|
|
craftingFailed = false;
|
|
}
|
|
HandleNextStep();
|
|
}
|
|
}
|
|
|
|
private void OpenTable(Location location)
|
|
{
|
|
SendPlaceBlock(location, Direction.Up);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prepare the crafting action steps by the given recipe name and start crafting
|
|
/// </summary>
|
|
/// <param name="recipe">Name of the recipe to craft</param>
|
|
private void PrepareCrafting(string name)
|
|
{
|
|
PrepareCrafting(recipes[name]);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prepare the crafting action steps by the given recipe and start crafting
|
|
/// </summary>
|
|
/// <param name="recipe">Recipe to craft</param>
|
|
private void PrepareCrafting(Recipe recipe)
|
|
{
|
|
recipeInUse = recipe;
|
|
if (recipeInUse.CraftingAreaType == ContainerType.PlayerInventory)
|
|
inventoryInUse = 0;
|
|
else
|
|
{
|
|
var inventories = GetInventories();
|
|
foreach (var inventory in inventories)
|
|
if (inventory.Value.Type == ContainerType.Crafting)
|
|
inventoryInUse = inventory.Key;
|
|
if (inventoryInUse == -2)
|
|
{
|
|
// table required but not found. Try to open one
|
|
OpenTable(tableLocation);
|
|
waitingForTable = true;
|
|
SetTimeout(Translations.Get("bot.autoCraft.table_not_found"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (recipe.Materials != null)
|
|
{
|
|
foreach (KeyValuePair<int, ItemType> slot in recipe.Materials)
|
|
{
|
|
// Steps for moving items from inventory to crafting area
|
|
actionSteps.Add(new ActionStep(ActionType.LeftClick, inventoryInUse, slot.Value));
|
|
actionSteps.Add(new ActionStep(ActionType.LeftClick, inventoryInUse, slot.Key));
|
|
}
|
|
}
|
|
if (actionSteps.Count > 0)
|
|
{
|
|
// Wait for server to send us the crafting result
|
|
actionSteps.Add(new ActionStep(ActionType.WaitForUpdate, inventoryInUse, 0));
|
|
// Check the crafting result is the item we want
|
|
actionSteps.Add(new ActionStep(ActionType.CheckResult, inventoryInUse, recipe.ResultItem));
|
|
// Put item back to inventory. (Using shift-click can take all item at once)
|
|
actionSteps.Add(new ActionStep(ActionType.ShiftClick, inventoryInUse, 0));
|
|
// We need to wait for server to update us after taking item from crafting result
|
|
actionSteps.Add(new ActionStep(ActionType.WaitForUpdate, inventoryInUse));
|
|
// Repeat the whole process again
|
|
actionSteps.Add(new ActionStep(ActionType.Repeat));
|
|
// Start crafting
|
|
LogToConsoleTranslated("bot.autoCraft.start", recipe.ResultItem);
|
|
HandleNextStep();
|
|
}
|
|
else LogToConsoleTranslated("bot.autoCraft.start_fail", recipe.ResultItem);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stop the crafting process by clearing crafting action steps and close the inventory
|
|
/// </summary>
|
|
private void StopCrafting()
|
|
{
|
|
actionSteps.Clear();
|
|
// Put item back to inventory or they will be dropped
|
|
ClearCraftingArea(inventoryInUse);
|
|
// Closing inventory can make server to update our inventory
|
|
// Useful when
|
|
// - There are some items left in the crafting area
|
|
// - Resynchronize player inventory if using crafting table
|
|
if (GetInventories().ContainsKey(inventoryInUse))
|
|
{
|
|
CloseInventory(inventoryInUse);
|
|
LogToConsoleTranslated("bot.autoCraft.close_inventory", inventoryInUse);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle next crafting action step
|
|
/// </summary>
|
|
private void HandleNextStep()
|
|
{
|
|
while (actionSteps.Count > 0)
|
|
{
|
|
if (waitingForUpdate || waitingForMaterials || craftingFailed) break;
|
|
ActionStep step = actionSteps[index];
|
|
index++;
|
|
switch (step.ActionType)
|
|
{
|
|
case ActionType.LeftClick:
|
|
if (step.Slot != -2)
|
|
{
|
|
WindowAction(step.InventoryID, step.Slot, WindowActionType.LeftClick);
|
|
}
|
|
else
|
|
{
|
|
int[] slots = GetInventories()[step.InventoryID].SearchItem(step.ItemType);
|
|
if (slots.Length > 0)
|
|
{
|
|
int ignoredSlot;
|
|
if (recipeInUse!.CraftingAreaType == ContainerType.PlayerInventory)
|
|
ignoredSlot = 9;
|
|
else
|
|
ignoredSlot = 10;
|
|
slots = slots.Where(slot => slot >= ignoredSlot).ToArray();
|
|
if (slots.Length > 0)
|
|
WindowAction(step.InventoryID, slots[0], WindowActionType.LeftClick);
|
|
else
|
|
craftingFailed = true;
|
|
}
|
|
else craftingFailed = true;
|
|
}
|
|
break;
|
|
|
|
case ActionType.ShiftClick:
|
|
if (step.Slot == 0)
|
|
{
|
|
WindowAction(step.InventoryID, step.Slot, WindowActionType.ShiftClick);
|
|
}
|
|
else craftingFailed = true;
|
|
break;
|
|
|
|
// Compare the crafting result with the recipe result
|
|
case ActionType.CheckResult:
|
|
if (GetInventories()[step.InventoryID].Items.ContainsKey(0)
|
|
&& GetInventories()[step.InventoryID].Items[0].Type == step.ItemType)
|
|
{
|
|
// OK
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Bad, reset everything
|
|
ClearCraftingArea(step.InventoryID);
|
|
index = 0;
|
|
}
|
|
break;
|
|
|
|
case ActionType.WaitForUpdate:
|
|
if (step.InventoryID != -2)
|
|
{
|
|
waitingForUpdate = true;
|
|
}
|
|
else craftingFailed = true;
|
|
break;
|
|
|
|
case ActionType.ResetCraftArea:
|
|
if (step.InventoryID != -2)
|
|
ClearCraftingArea(step.InventoryID);
|
|
else
|
|
craftingFailed = true;
|
|
break;
|
|
|
|
case ActionType.Repeat:
|
|
index = 0;
|
|
break;
|
|
}
|
|
HandleError();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle any crafting error after a step was processed
|
|
/// </summary>
|
|
private void HandleError()
|
|
{
|
|
if (craftingFailed)
|
|
{
|
|
if (actionSteps[index - 1].ActionType == ActionType.LeftClick && actionSteps[index - 1].ItemType != ItemType.Air)
|
|
{
|
|
// Inform user the missing meterial name
|
|
LogToConsoleTranslated("bot.autoCraft.missing_material", actionSteps[index - 1].ItemType.ToString());
|
|
}
|
|
if (abortOnFailure)
|
|
{
|
|
StopCrafting();
|
|
LogToConsoleTranslated("bot.autoCraft.aborted");
|
|
}
|
|
else
|
|
{
|
|
waitingForMaterials = true;
|
|
// Even though crafting failed, action step index will still increase
|
|
// we want to do that failed step again so decrease index by 1
|
|
index--;
|
|
LogToConsoleTranslated("bot.autoCraft.craft_fail");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Put any item left in the crafting area back to inventory
|
|
/// </summary>
|
|
/// <param name="inventoryId">Inventory ID to operate with</param>
|
|
private void ClearCraftingArea(int inventoryId)
|
|
{
|
|
if (GetInventories().ContainsKey(inventoryId))
|
|
{
|
|
var inventory = GetInventories()[inventoryId];
|
|
int areaStart = 1;
|
|
int areaEnd = 4;
|
|
if (inventory.Type == ContainerType.Crafting)
|
|
{
|
|
areaEnd = 9;
|
|
}
|
|
List<int> emptySlots = inventory.GetEmpytSlots().Where(s => s > 9).ToList();
|
|
for (int i = areaStart; i <= areaEnd; i++)
|
|
{
|
|
if (inventory.Items.ContainsKey(i))
|
|
{
|
|
if (emptySlots.Count != 0)
|
|
{
|
|
WindowAction(inventoryId, i, WindowActionType.LeftClick);
|
|
WindowAction(inventoryId, emptySlots[0], WindowActionType.LeftClick);
|
|
emptySlots.RemoveAt(0);
|
|
}
|
|
else
|
|
{
|
|
WindowAction(inventoryId, i, WindowActionType.DropItemStack);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HandleUpdateTimeout()
|
|
{
|
|
LogToConsoleTranslated("bot.autoCraft.timeout", timeoutAction);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the timeout. Used to detect the failure of open crafting table
|
|
/// </summary>
|
|
/// <param name="reason">The reason to display if timeout</param>
|
|
private void SetTimeout(string reason = "unspecified")
|
|
{
|
|
updateTimeout = updateTimeoutValue;
|
|
timeoutAction = reason;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear the timeout
|
|
/// </summary>
|
|
private void ClearTimeout()
|
|
{
|
|
updateTimeout = 0;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|