No-Code Workspace — Block Reference

SearchBlock usage recipe

Visual Target (VISUAL_TARGET)

Identifies and reacquires one target across multiple views

Documented for app version 1.0.50Updated: October 2, 2026

Visual Target (VISUAL_TARGET) block card

What Does It Do?

Combines multiple reference views of one target—such as front, side, near, or far—into a single profile. It selects the best view on live frames, publishes position, velocity, and state while the target moves, and attempts reacquisition after a brief loss. Besides classical image matchers it can use an identity profile taught on the device from live frames; it does not perform semantic person classification or true 3D reconstruction.

Shared Mechanics for Search Blocks

Multiple search regions and excluded regions

IMAGE, TEXT, COLOR and the other search blocks that use the Search Regions editor can define several search regions with + Add Region; OCR_VALUE tries its read regions in order. Inside a search region, Exclude Region skips noisy areas such as a HUD or a badge, and it applies only to the search region it belongs to. From 1.0.51 one search region can hold several excluded regions, each with its own shape and its own variable or Dialog binding.Coming soonv1.0.51

Sticky anchors for edge-aware scaling

You can now assign a sticky anchor to each search region. This brings Region.sticky into the no-code surface so the region can stay aligned to anchors such as top_left, bottom_right, or center when screen geometry changes.

Scan rate, duration, and retry behavior

Search Duration (ms) defines one search window; 0 means a single look. Retry Mode in the Retry & Wait section is Off, Infinite Loop, Retry On True, Retry On False, Wait Until Found, or Wait Until Gone, so a block becomes a one-shot check, a controlled polling step, or a step that waits for a target to appear or to disappear. Retry Timeout (ms, 0 = unlimited) bounds the loop; Scan Rate (Hz) sets scans per second.

Match tuning and device variance

mScore, scale, and scan engine choices matter across themes, display sizes, and rendering differences. Smaller regions plus the right engine dramatically improve builder stability.

When to Use?

Use it when one template is not enough:

The same character appears at different angles or scales

A taught target must be distinguished among look-alikes

The target disappears briefly and returns

You need to click it, swipe toward it, or branch on moving/still state

How to Use?

Add "Visual Target"

Name the target profile

Add 1–32 reference views and give each a meaningful label

Restrict the search region; add an exclusion region when needed

Start with the Hybrid engine and calibrate acquire/retain thresholds

Tune max drift, lost-frame, movement, and still-frame limits to the target speed

Choose an output prefix; consume found/status/x/y/width/height/center/similarity/view/movement/velocity/lastSeen/lostFrames in later blocks

Put actions for an acquired target on TRUE and timeout or permanent-loss handling on FALSE

Parameters

Target Profile / Views

A profile name with 1–32 labelled reference views

Identity Engine

Hybrid (default), Feature / ORB, Shape / Edge, Balanced Image, Smart Reference, Learned Identity, Learned + Image and Adaptive Identity Fusion

Teach Target

Teaches the learned engines from the live screen on the device: pick a tight crop around only the target and tap Teach Target; the profile stays on this device unless you share the macro privately, send it to another account, export it as ZIP or back it up to your Premium vault

Acquire / Retain Threshold

Scores for acquiring a new target and retaining its identity

Drift / Lost / Reacquire

Per-frame movement radius, loss tolerance, and reacquisition

Movement / Stillness

Movement threshold and frames required before declaring stillness

Candidates / Adaptive Scan

1–16 candidates per view and controlled slowdown while the target is still

Output Prefix

Safe Lua variable prefix for the 15 target outputs

Parameter	Description
Target Profile / Views	A profile name with 1–32 labelled reference views
Identity Engine	Hybrid (default), Feature / ORB, Shape / Edge, Balanced Image, Smart Reference, Learned Identity, Learned + Image and Adaptive Identity Fusion
Teach Target	Teaches the learned engines from the live screen on the device: pick a tight crop around only the target and tap Teach Target; the profile stays on this device unless you share the macro privately, send it to another account, export it as ZIP or back it up to your Premium vault
Acquire / Retain Threshold	Scores for acquiring a new target and retaining its identity
Drift / Lost / Reacquire	Per-frame movement radius, loss tolerance, and reacquisition
Movement / Stillness	Movement threshold and frames required before declaring stillness
Candidates / Adaptive Scan	1–16 candidates per view and controlled slowdown while the target is still
Output Prefix	Safe Lua variable prefix for the 15 target outputs

Example Usage

Example: find a character across viewpoints and steer toward it

Add front, left, right, near, and far views

Restrict the region to the play area and exclude static HUD chrome

Acquire = 0.82, retain = 0.72, reacquire = on

COMPARE visual_target_center_x with the screen centre

SWIPE LEFT when left and SWIPE RIGHT when right

CLICK the target centre after visual_target_height crosses the near-distance threshold

Combinations / Used With

VISUAL_TARGET + COMPARE: decide from score, position, size, and state

VISUAL_TARGET + CLICK: tap the acquired target

VISUAL_TARGET + SWIPE: steer toward the target

VISUAL_TARGET + WAIT/LOG: observe loss and reacquisition

VISUAL_TARGET + SET_VARIABLE: persist the last observed target state

Tip

Identifies and reacquires one target across multiple views

Warnings / Cautions

WARNING:

Each view must be a tightly cropped, clean image of the real target

A wide region, many views, and high Hz increase CPU and battery cost

Low thresholds can switch identity among close look-alikes

Too-small maxDrift loses fast targets; too-large maxDrift can jump to a neighbour

This release is multi-view visual matching, not biometric recognition, real depth, or semantic 3D understanding

Step-by-Step Mastery: Basic → Advanced → Pro

The same block at three levels: a quick start, the real options, and professional techniques.

Basic

VISUAL_TARGET searches for different angles, scales, or appearances of one target under a single profile. For the simplest reliable setup, add front, side, and far views as separate templates, narrow the search region, use the hybrid engine, and CLICK the acquired centre. The block distinguishes first acquisition, live tracking, brief loss, and reacquisition.

Advanced

The acquire threshold accepts a new identity, while the retain threshold keeps an already acquired identity; do not set retain above acquire. maxDriftPx is the radius the target may move between scans. lostFrameLimit tolerates brief occlusion; when reacquire is enabled, every view is searched again after a persistent loss. maxCandidatesPerView is a performance ceiling. An exclusion region prevents static HUD chrome or a similar decoration from becoming a candidate. adaptiveScan moderately increases the interval while the target is still to reduce CPU and battery use. The Identity Engine has eight options: Hybrid (default), Feature / ORB, Shape / Edge, Balanced Image, Smart Reference (scores pixel, colour-layout, tone, edge and full-palette evidence of the reference in each candidate), Learned Identity (a profile taught on the device from the live screen), Learned + Image (the learned profile plus your authored views) and Adaptive Identity Fusion (combines learned identity with the other evidence; a new target needs agreement from at least two independent engines).

Pro

For professional calibration, begin with a low-cost region and 3–5 distinctive views. Give each view a meaningful label such as front/left/near; this is not a search keyword, it names the winning template in visual_target_view and may be supplied at runtime through a variable/Dialog bulb. Match Score Test evaluates every view and the selected engine instead of only the first image. Measure visual_target_similarity on the real target and look-alikes, then place the acquire threshold between the two clusters. visual_target_velocity_x/y describes screen motion and width/height approximates on-screen proximity, not real 3D distance. x/y is the top-left bound; center_x/center_y is the action centre. The code editor exposes the same engine through VisualTarget.profile/refresh/step/snapshot/reset/click/swipeToward.

Real-World Scenarios — Step-by-Step Recipes

Small, reproducible examples that combine several blocks — build them straight into your own macro.

Approach and tap a target across viewpoints

1Add front/left/right/near/far views
2Search the play area and exclude static HUD chrome
3Compare center_x with the screen centre
4SWIPE in the appropriate direction when the target is left/right
5CLICK the centre after height crosses the near threshold

Handle loss and reacquisition safely

1Set lostFrameLimit high enough to cover brief effects
2Keep reacquire enabled
3Do not act on status=lost; write a LOG entry
4Recheck the score on status=reacquired
5Resume CLICK/SWIPE only after validation

Teach the target on the device (Teach Target)

1Identity Engine = Learned + Image
2Target Crop for Teaching: pick a tight box around only the target (separate from the search area)
3Set Teaching Duration, Teaching Samples / sec and Maximum Learned Views
4Tap Teach Target and grant screen capture; let the target's angle or distance change while it teaches
5Once "Profile ready on this device" shows, measure the acquire threshold on the real target and look-alikes

Which Blocks to Pair With — Pro Combinations

This block is useful on its own — but it shines when paired with the right partners.

+ COMPARE

Gate status, similarity, centre, and size together to avoid acting on a wrong target.

+ CLICK / SWIPE

Use the live centre and velocity outputs to tap the current position or steer toward it.

+ LOG / WAIT

Measure loss, reacquisition, and score distributions, then calibrate thresholds from data.

Common Mistakes and Fixes

Adding the same animation frame under many view names adds no diversity. Fix: teach genuinely different angles, scales, or appearances with clean crops.

Using only Feature / ORB for tiny or distant character crops can yield zero keypoints and a complete miss. Fix: begin with Hybrid, use sufficiently large sharp crops that distinguish the target from its surroundings, and validate every view with Match Score Test.

A short scan window such as 500 ms can end a multi-view block before all template and engine attempts complete. Fix: start with at least max(1000 ms, view count × 250 ms), then reduce it only after measurement on the target device.

Scanning full screen at high Hz with 32 views adds needless cost. Fix: narrow the region, start with 3–5 views, and raise the candidate limit only after measurement.

Treating on-screen size as real 3D distance is incorrect. Fix: use width/height only as a calibrated proximity indicator under the same game/camera conditions.

Teaching while the target stands still: too few different views are captured and teaching fails. Fix: move, turn or animate the target while it teaches, and keep the screen rotation unchanged.

Pro Tips

When identity jumps to a look-alike, add a distinctive side/back view and exclude the static look-alike area before merely raising the acquire threshold.

Choose the output prefix from the target name (for example, boss) so multiple VISUAL_TARGET blocks never collide.

Coming soonv1.0.51Add several exclusions to the search region with "+ Exclude Region"; excluding the fixed HUD and look-alike decorations separately reduces identity jumps.

This Block's Code (Editor View)

Lua

The Lua below is what the Code Editor generates for this block with sample settings. Adding cases, branches, actions or loops, or changing settings, extends the generated code accordingly. Study it to see what the block does under the hood, to learn Lua, or to copy and adapt it. Use the Copy button (top-right) to paste it into the Code Editor, or “Try in Editor →” to run it in the live editor.

lua

Try in Editor →

local visual_target_found = nil
local visual_target_status = nil
local visual_target_x = nil
local visual_target_y = nil
local visual_target_width = nil
local visual_target_height = nil
local visual_target_center_x = nil
local visual_target_center_y = nil
local visual_target_similarity = nil
local visual_target_view = nil
local visual_target_engine = nil
local visual_target_moving = nil
local visual_target_velocity_x = nil
local visual_target_velocity_y = nil
local visual_target_last_seen_ms = nil
local visual_target_lost_frames = nil
local visual_target_consensus_votes = nil
local visual_target_consensus_engines = nil
local visual_target_error = nil
local visual_target_pixel_score = nil
local visual_target_color_score = nil
local visual_target_tone_score = nil
local visual_target_edge_score = nil
local visual_target_palette_score = nil

local _vtAcquire1 = 0.82
local _vtRetain1 = math.min(_vtAcquire1, 0.72)
local _vtViews1 = {
 { name = tostring("front"), template = Asset.image("btn_play"):mScore(_vtAcquire1) },
 { name = tostring("side"), template = Asset.image("btn_play_side"):mScore(_vtAcquire1) },
}
__mh_visual_target_profiles = __mh_visual_target_profiles or {}
local _vtProfileKey1 = "00000000-0000-4000-8000-000000000001"
local _vtProfile1 = VisualTarget.refresh(__mh_visual_target_profiles[_vtProfileKey1], "guard", _vtViews1, {
 engine = "hybrid",
 stateKey = "",
 acquireThreshold = _vtAcquire1,
 retainThreshold = _vtRetain1,
 maxDriftPx = (function() local _refLen = tonumber(160.0) or 0; if _refLen ~= _refLen or _refLen == math.huge or _refLen == -math.huge then _refLen = 0 end; _refLen = math.max(0, _refLen); if _refLen == 0 then return 0 end; local _origin = Point(2, 2); local _unitX = Point(3, 2); local _unitY = Point(2, 3); local function _unresolved(_point) return type(_point) == "table" and _point.__mh_point_unresolved == true end; if _origin == nil or _unitX == nil or _unitY == nil or _unresolved(_origin) or _unresolved(_unitX) or _unresolved(_unitY) then error("Reference length mapping failed") end; local _scaleX = math.abs(_unitX:getX() - _origin:getX()); local _scaleY = math.abs(_unitY:getY() - _origin:getY()); return _refLen * math.max(_scaleX, _scaleY) end)(),
 lostFrameLimit = 4,
 reacquire = true,
 movementThresholdPx = (function() local _refLen = tonumber(4.0) or 0; if _refLen ~= _refLen or _refLen == math.huge or _refLen == -math.huge then _refLen = 0 end; _refLen = math.max(0, _refLen); if _refLen == 0 then return 0 end; local _origin = Point(2, 2); local _unitX = Point(3, 2); local _unitY = Point(2, 3); local function _unresolved(_point) return type(_point) == "table" and _point.__mh_point_unresolved == true end; if _origin == nil or _unitX == nil or _unitY == nil or _unresolved(_origin) or _unresolved(_unitX) or _unresolved(_unitY) then error("Reference length mapping failed") end; local _scaleX = math.abs(_unitX:getX() - _origin:getX()); local _scaleY = math.abs(_unitY:getY() - _origin:getY()); return _refLen * math.max(_scaleX, _scaleY) end)(),
 stillFrameLimit = 3,
 adaptiveScan = true,
 maxCandidatesPerView = 8,
})
__mh_visual_target_profiles[_vtProfileKey1] = _vtProfile1
local _vtRegions1 = {
 { region = Region(0, 0, 540, 960) },
}
local _vtStarted1 = System.currentTime()
local _vtTimeout1 = 5000
local _vtScanRate1 = 8
local _vtInterval1 = math.max(1, math.floor(1000 / _vtScanRate1))
local _vtDone1 = false
while not _vtDone1 do
 Snap.screenRefresh()
 local _vt1 = VisualTarget.step(_vtProfile1, _vtRegions1)
 visual_target_found = _vt1.found == true
 visual_target_status = _vt1.status or "searching"
 visual_target_x = _vt1.x or 0
 visual_target_y = _vt1.y or 0
 visual_target_width = _vt1.w or 0
 visual_target_height = _vt1.h or 0
 visual_target_center_x = _vt1.centerX or 0
 visual_target_center_y = _vt1.centerY or 0
 visual_target_similarity = _vt1.score or 0
 visual_target_view = _vt1.viewName or ""
 visual_target_engine = _vt1.engine or ""
 visual_target_moving = _vt1.moving == true
 visual_target_velocity_x = _vt1.velocityX or 0
 visual_target_velocity_y = _vt1.velocityY or 0
 visual_target_last_seen_ms = _vt1.lastSeenMs or 0
 visual_target_lost_frames = _vt1.lostFrames or 0
 visual_target_consensus_votes = _vt1.consensusVotes or 0
 visual_target_consensus_engines = _vt1.consensusEngines or ""
 visual_target_error = _vt1.error or ""
 visual_target_pixel_score = _vt1.pixelScore or 0
 visual_target_color_score = _vt1.colorScore or 0
 visual_target_tone_score = _vt1.toneScore or 0
 visual_target_edge_score = _vt1.edgeScore or 0
 visual_target_palette_score = _vt1.paletteScore or 0
 if _vt1.found then
  _lastMatch = _vt1.match
 elseif _vt1.status == "lost" then
  _lastMatch = nil
 elseif _vt1.status == "error" then
  _lastMatch = nil
  System.log("Visual Target scan error: " .. tostring(_vt1.error or "unknown"))
  _vtDone1 = true
 end
 if _vtTimeout1 == 0 then
  _vtDone1 = true
 elseif System.currentTime() - _vtStarted1 >= _vtTimeout1 then
  visual_target_status = "timeout"
  _vtDone1 = true
 end
 if not _vtDone1 then wait((_vt1.status == "still" and math.min(1000, _vtInterval1 * 2) or _vtInterval1)) end
end

Note: generated code can evolve across versions; helper names (e.g. _reg1, m1) and internal optimizations may change. The logic and the called APIs reflect the block’s behavior.

Block ↔ Lua Mapping →

Shared Controls for This Block Family

The guidance below is not identical for every block. It summarizes the professional controls that most often repeat in the selected block family.

🔎Scan Region

Keep the search close to the target. Smaller regions are faster and more stable.

🚫Exclude Region

Exclude static noise, badges, animations, or reflective areas to reduce false matches.

⏱Timeout and Scan Rate

Timeout and scan rate define whether the block acts as a single check or controlled polling step.

🎯Match Tuning

mScore, scale, and engine choice must be tuned together for theme, resolution, and rendering differences.

🧭Result Variables

OCR_VALUE writes the number it reads to its result variable (default ocr_val); TEXT writes the text it passed through its find/replace step to the Save Read Value variable (default ocr_val). In Match Variables, the score variable (0.0–1.0 confidence) and the X/Y/W/H variables carry the match confidence and position into later blocks: branch on the score with COMPARE, and in CLICK bind the coordinates to them with {x} or turn on Click on match. _lastMatch is the last match that Click on match uses; _lastOcrText is kept only for older CUSTOM_CODE scripts.

Builder vs Lua Boundary

Raw touch pointer lifecycle stays code-first

TOUCH and TOUCH_BREAK cover recipe-style touch flows. Raw pointer choreography such as Touch.down, Touch.move, Touch.up, Touch.dispatch, Touch.reset, Touch.breakAll, and Touch.releaseAfter is not exposed as a first-class builder block.

Touch.downTouch.moveTouch.upTouch.dispatchTouch.resetTouch.breakAllTouch.releaseAfter

Bounded dialog design is builder-backed; freer composition stays code-first

The DIALOG block and dialog designer cover a bounded field set in the builder: Info Text, Text Input, Checkbox, Description, Radio Group, Dropdown, Multi Select, Tab Group, Date Time, Number Range, Slider, Image Picker, Color Picker, File Picker, Recorder Picker, Tag, Signature, and Spacer. The buttons are designed too: the Positive button and Negative button tabs set each button’s text, background, and border color, corner radius, and minimum height next to a preview. Freer Setting.builder composition, multi-step wizard flows, and mixed HUD/dialog choreography still do not map 1:1 into the builder.

Coming soonv1.0.51Two more fields: Agent Detect references (agent_detect_editor) lets the user pick a saved reference set or add and edit references, and Save confirms the selection; Navigation setup editor (navigation_editor) edits a saved map, marker and route from the Dialog and returns the setup and route selection without moving the character.

Setting.builderDialogHudTextViewAgentDetectEditorNavigationEditor

Advanced HTTP request chaining stays code-first

HTTP_GET, HTTP_POST, and HTTP_PUT cover common fixed-method flows; HTTP_REQUEST covers one bounded request with method, header lines, body, content type, query parameters (GET and DELETE), timeout, and a bounded retry. These blocks never throw; they write the status code (-1 on a network failure). Cookie handling, chained request objects, and lower-level client flows still need the code editor.

Request()Request.setCookieRequest.getCookiesCUSTOM_CODE

General programming surfaces stay code-first

The MAP, LIST, JSON_PARSE, REGEX_MATCH, and METRICS blocks cover the everyday cases: map actions, a static list, reading a value from a JSON path, regex match, find, replace, and split, and metrics actions. The rest of the Map, Array, JSON, Regex, and Metrics APIs (for example Array sort, filter, and map) is broader than the builder recipe model and stays on the CUSTOM_CODE and code editor side.

MapArrayJSONRegexMetrics

Low-level runtime and Lua composition stays code-first

Runtime helpers, raw Request objects, Lua built-ins such as print/pcall/xpcall, and free-form object chaining patterns are represented through CUSTOM_CODE or the code editor.

RuntimeRequestprintpcallxpcallCUSTOM_CODE

Debug Mode and Breakpoints

Each block card now exposes an independent breakpoint toggle. When enabled, the breakpoint preference is stored with the block.

Breakpoints are only emitted into runtime code when Debug Mode is enabled from Visual Builder settings. When Debug Mode is off, breakpoints stay saved but do not pause execution.

Use ASSERT for fail-fast validation, and use breakpoints for step-by-step tracing and controlled pauses in the same flow.

Variable Scope

Variables defined with SET_VARIABLE are accessible throughout the macro (global scope). All blocks can read/write the same variable.

However, a variable defined inside a GROUP will be 'nil' (undefined) until the GROUP executes. Blocks outside the GROUP using this variable may produce unexpected results.

FOR_EACH loop variables (item and index) only carry valid values inside the loop body. Outside the loop they are outside local scope and should not be used.

TRY_CATCH error variable is only valid within the catch block. If the try block succeeds, the catch branch is not entered and the error variable remains undefined.

TIP: Before using a variable inside a GROUP, assign a default value with SET_VARIABLE outside the GROUP. This way the variable won't be nil even if the GROUP has not run.

Inline Expressions

You can embed variable values and calculations into text fields using {{ expression }} syntax. Expressions inside double curly braces are evaluated as Lua code and the result is inserted into the text.

Syntax

{{ expression }}

Examples

Skor: {{ score + 1 }} → "Skor: " .. tostring(score + 1)

{{ name }} kazandı! → tostring(name) .. " kazandı!"

X:{{ x }} Y:{{ y }} → "X:" .. tostring(x) .. " Y:" .. tostring(y)

Supported Blocks

SET_VARIABLELOGCOMPARECLIPBOARD_WRITENOTIFY_TOASTKV_SET

Security Note

Expressions are checked by the sandbox policy. Security-sensitive calls like loadstring, require, debug are automatically blocked.

General Tips

Keep scan regions as small as possible — improves speed, reduces false matches.

Always add an exit condition when using infinite loops (BREAK, timeout, or conditional exit).

Use network operations and error-prone steps inside TRY_CATCH.

If you need global error handling, use the Error Handler (ERROR_HANDLER) block as a singleton in the project.

Small coordinate offsets (CLICK/SWIPE) improve tap accuracy across different DPI and screen scales.

Customize macros with Dialog block — different parameters each run.

Define repeating steps once with GROUP_CALL, call from many places.

Cross-macro local library

Local Shared Macro Area

The Local Shared Macro Area moves blocks, variables, dialog fields, gallery assets, and imported media dependencies between macros on the same device. It is device-local, not cloud sync, not Firebase sharing, and not a replacement for public macro sharing.

Professional usage model: put a reusable login flow, common scan region, shared dialog form, variable group, template image, color profile, replay recording, or imported PLAY_SOUND media file into the shared area from one macro, then import it from the relevant + menu in another macro.

VISUAL_BLOCKSVARIABLESDIALOG_FIELDSTEMPLATE_IMAGECOLOR_SWATCHREPLAY_RECORDMEDIA_FILE

Send to the shared area

When one item or a multi-selection is active, the shared-area button can copy the selected part from the workspace, group, true/false action branch, dialog, and variables surfaces into the device-local library.

Import into another macro

The shared-area entry under the + menu imports the selected item into the surface that opened it. Main workspace, group, action branch, dialog, and variables each receive the compatible item type.

Share gallery assets

Gallery items include template images, color swatches, replay records, and imported audio/media files. They can move between macros on the same device so repeated templates, colors, recordings, and PLAY_SOUND media assets do not need to be captured again.

Keep it clean

The shared area is not a permanent dumping ground. Delete stale shared items from the shared-library panel; imports create a copy in the target macro and do not rewrite the source macro flow.

Checkpoint: after importing, review block names, linked template/image/color/record/media assets, and variable names in the target macro. The shared area creates a copy; delete stale shared items from the shared-library panel to keep the library clean.

AI assistant

Build a block chain with MH AI in natural language

Tell MH AI what you want in plain language; it proposes the right block sequence and lands it in the workspace after you approve. In the current release it works with cloud providers such as Gemini, Claude, and OpenAI; on-device local models are on the roadmap.

Learn more →