Make¶

The “Make” menu is the Chat box menu that pops up when you attempt to craft certain items in game.

TMakeQuantityButton type¶

Helper record used to cache make menu buttons.

TMakeItem¶

Helper record used to cache make menu items.

TMake¶

Main record used to interact with the Make menu.

Make.SetupInterface¶

procedure TMake.SetupInterface();

Internal method used to setup the TMake coordinates.

This is automatically called for you on the Make variable.

Make.IsOpen¶

function TMake.IsOpen(): Boolean;

Returns True/False if the Make if open.

Example:

WriteLn Make.IsOpen();

Make.WaitOpen¶

function TMake.WaitOpen(time: Integer = TICK; interval: Integer = -1): Boolean;

Returns True if the Make opens within time milliseconds.

Example:

WriteLn Make.WaitOpen();

Make.GetItemBoxes¶

function TMake.GetItemBoxes(): TBoxArray;

Returns the available item buttons as a TBoxArray.

Example:

ShowOnTarget(Make.GetItemBoxes());

Make.GetQuantityBoxes¶

function TMake.GetQuantityBoxes(): TBoxArray;

Finds quantity button boundaries and returns them as a TBoxArray.

You have 2 ways of getting the quantity boxes, a static one:

ShowOnTarget(Make.QuantityButtons);

../../images/make_static_quantity_boxes.png — The make static boxes.¶

And a dynamic one:

ShowOnTarget(Make.GetQuantityBoxes());

../../images/make_quantity_boxes.png — The make “dynamic” boxes.¶

There are use cases for both, internally, Make.GetQuantityBoxes is usually used.

Make.GetQuantityButtons()¶

function TMake.GetQuantityButtons(): array of TMakeQuantityButton;

Returns the visible quantity buttons as a array of TMakeQuantityButton.

Example:

WriteLn Make.GetQuantityButtons();

Make.FindQuantityButtons¶

function TMake.FindQuantityButtons(): array of TMakeQuantityButton;

Attempts to find and return all quantity buttons in the Make interface. This is a safe wrapper around GetQuantityButtons() that first verifies the Make interface is open before attempting to locate the buttons.

Returns an empty array if the Make interface is not currently open.

Example:

var
  buttons: array of TMakeQuantityButton;
  i: Integer;
begin
  buttons := Make.FindQuantityButtons();
  for i := 0 to High(buttons) do
    WriteLn('Button ', i, ' bounds: ', buttons[i].Button.Bounds);
end;

Make.GetCurrentQuantityButton¶

function TMake.GetCurrentQuantityButton(): Integer;

Get the current active make quantity button.

Example:

current := Make.GetCurrentQuantityButton();
WritLn current;
ShowOnTarget(current.Button.Bounds);

Make.GetCurrentQuantity¶

function TMake.GetCurrentQuantity(): Integer;

Get the current active make quantity as an integer. If All button is current then returns -1.

Example:

current := Make.GetCurrentQuantityButton();
WritLn current;
ShowOnTarget(current.Button.Bounds);

Make.HasHint¶

function TMake.HasHint(): Boolean;

Returns true if a hint tooltip is visible.

Example:

if Make.HasHint() then
  ShowOnTarget(Make.GetHintBox());

Make.WaitHint¶

function TMake.WaitHint(time: Integer = TICK; interval: Integer = -1): Boolean;

Returns true if a hint tooltip is visible within time milliseconds.

Example:

if Make.WaitHint() then
  ShowOnTarget(Make.GetHintBox());

Make.GetHintBox¶

function TMake.GetHintBox(): TBox;

Returns the hint tooltip bounds.

Example:

ShowOnTarget(Make.GetHintBox());

Make.ReadHint¶

function TMake.ReadHint(): String;

Returns the hint tooltip text.

Example:

WriteLn Make.ReadHint();

Make.CloseHint¶

function TMake.CloseHint(): Boolean;

Attempts to close a hint tooltip.

Example:

WriteLn Make.CloseHint();

Make.QuantityButtons¶

The quantity buttons are dynamic there can be anywhere from 1 to 6 available.

You have their coordinates available at anytime through the TMake.QuantityButtons variable:

ShowOnTarget(Make.QuantityButtons);

../../images/make_quantities.png — The make interface quantity buttons.¶

Despite them being always available you should only interact with the ones that are visible which you can do easily through the next methods.

Make.FindQuantityButton¶

function TMake.FindQuantityButton(amount: Integer): TMakeQuantityButton;

Finds and returns the TMakeQuantityButton matching the specified amount.

For standard quantities (1, 5, 10, All), returns the corresponding button directly. For custom amounts, prioritizes a button already set to that value, otherwise returns the “Other” (X) button which will prompt for manual entry.

Returns an empty record if no matching button is found or the Make interface is not open.

Note: Automatically closes any tooltip that may be covering the quantity buttons.

Example:

var
  btn: TMakeQuantityButton;
begin
  btn := Make.FindQuantityButton(5);
  if btn <> [] then
    WriteLn('Found button: ', btn);
end;

Make.IsQuantitySelected¶

function TMake.IsQuantitySelected(idx: Integer): Boolean;

Checks if the specified idx quantity button is currently selected.

Example:

WriteLn Make.IsQuantitySelected(Make.QUANTITY_ALL);

Make.SetQuantity¶

function TMake.SetQuantity(amount: Integer): Boolean;

Attempts to set a quantity.

Example:

WriteLn Make.SetQuantity(Make.QUANTITY_ALL);

Make._SelectHelper¶

function TMake._SelectHelper(index: Integer; boxes: TBoxArray; keyboardProbability: Single): Boolean;

Internal helper method that handles selecting an item with or without the keyboard. You probably will never need to use this directly.

Make.Select¶

function TMake.Select(index, quantity: Integer; keyboardProbability: Single = -1): Boolean;
function TMake.Select(item: String; quantity: Integer; keyboardProbability: Single = -1): Boolean; overload;

Select a index or an item of the available item buttons available. If you are selecting an item you need to use the tooltip text.

Example:

WriteLn Make.Select('Maple longbow', QUANTITY_ALL);

Make variable¶

Global TMake variable.