Nik Afiq 5a6d964fe8 Enhance OCR name matching and purchase handling in shop utilities
- Introduced a fallback mechanism using difflib for improved name matching when OCR results contain internal character corruption.
- Implemented a two-stage fallback for name matching: stripping whitespace and using similarity scoring if no exact or substring matches are found.
- Modified `select_targets_by_name` to handle incremental purchases, committing batches before reopening the shop tab to avoid under-purchases due to UI state resets.
- Added retry logic for handling OCR instability, allowing multiple attempts to read item names before resorting to reopening the shop tab.
- Updated the return values of `select_targets_by_name` to reflect purchased items and skipped targets, improving clarity on transaction outcomes.
2026-09-24 13:25:56 +09:00

672 lines
35 KiB
Python

"""Shared Common Shop / Tactical Shop grid logic.
Ported from baas-reference module/shop/shop_utils.py's get_item_position/
ensure_choose/buy pattern -- the checkbox-select-then-bulk-buy grid shared by
both shop tabs in the live client. Adapted from the reference's
color+template item-state scan to this project's fixed-grid-position +
price-OCR-verify design: unlike story_sweep, the reference's own
item-identification here isn't OCR at all -- it indexes into
self.static_config.common_shop_price_list, a table sourced from an external
resource this repo doesn't have. So a locally pixel-scanned, name-commented
position table (config.COMMON_SHOP_TARGETS / config.TACTICAL_SHOP_TARGETS) is
the faithful local equivalent, not a shortcut around OCR the reference uses.
Price-digit OCR -- something the reference doesn't even do per-item -- is
layered on top as an extra safety net against catalog drift, consistent with
this project's verify-before-spend pattern elsewhere (mailbox/cafe/story_sweep).
**Position turned out not to be fixed** (found live 2026-08-01, see
config.SHOP_PRICE_OCR_OFFSET's comment and script_error.md): Common Shop
sinks a sold-out item to the bottom of its (scrollable) grid and shifts
everything after it up, so a fixed (row, col) -> item mapping silently
drifts the moment anything sells out. `select_targets_by_name` below
replaces position-based identification with OCR'd item-name matching for
Common Shop specifically -- genuinely closer to the reference's own
item-identity-based (not position-based) design intent, just using a local
OCR read instead of the reference's external price-list index, for the
same "don't have that external table" reason the module docstring above
already gives. Tactical Shop (`select_targets`, unchanged) has never shown
this symptom -- one row, two items, no observed reordering -- so it stays
on the simpler position-based path rather than migrating speculatively.
"""
import difflib
from ba_auto import detector, navigation
# _match_name's last-resort fallback for OCR text with an internal inserted/
# dropped character that breaks plain substring containment (see that
# function's own docstring for the live incident and real similarity scores
# this was calibrated against).
SIMILARITY_THRESHOLD = 0.75
def _checkbox_center(config, row, col):
return config.SHOP_ITEM_COL_X[col], config.SHOP_ITEM_ROW_Y[row]
def _checkbox_region(config, row, col):
x, y = _checkbox_center(config, row, col)
return (x - 15, y - 15, x + 15, y + 15)
def _price_rect(config, row, col):
x, y = _checkbox_center(config, row, col)
x1, y1, x2, y2 = config.SHOP_PRICE_OCR_OFFSET
return (x + x1, y + y1, x + x2, y + y2)
def _name_rect(config, row, col):
x, y = _checkbox_center(config, row, col)
x1, y1, x2, y2 = config.SHOP_NAME_OCR_OFFSET
return (x + x1, y + y1, x + x2, y + y2)
def _is_checked(driver, config, row, col):
lo, hi = config.SHOP_CHECKED_RGB
return detector.region_contains_color(_checkbox_region(config, row, col), lo, hi)
def _is_purchasable(driver, config, row, col):
"""A sold-out/greyed buy button reads flat grey (B-R within +/-2 of 0,
no color tint at all); a live/purchasable one carries a strong blue
tint (B-R of +120 to +127) -- regardless of the button's own shimmer
animation, which swings its raw brightness a lot but not its tint (see
config.SHOP_BUTTON_PROBE_OFFSET's own comment for the live A/B that
found this; an earlier brightness-only check was fooled by it)."""
x, y = _checkbox_center(config, row, col)
dx, dy = config.SHOP_BUTTON_PROBE_OFFSET
r, g, b = driver.color_at(x + dx, y + dy)
return (b - r) > config.SHOP_BUTTON_PURCHASABLE_MIN_BLUE_TINT
def select_targets(driver, config, targets):
"""OCR-verify each target's price, then click its checkbox and confirm
it registers as checked. Returns (selected, skipped); a price mismatch
or an unconfirmed checkbox skips just that target rather than aborting
the whole run (mirrors story_sweep's per-target skip-not-abort design).
Re-reads the price up to config.SHOP_PRICE_OCR_RETRIES times, stopping
early on the first read that matches expected_price -- a real live run
misread one target's price by a single stray digit while every other
target (including other 6-digit prices) read correctly in the same run,
so a single bad frame shouldn't skip a real purchase. A genuine catalog
change still reads the same (wrong) value across every retry and gets
skipped as before. See config.SHOP_PRICE_OCR_RETRIES's own comment.
"""
selected = []
skipped = []
for row, col, name, expected_price in targets:
price = None
for attempt in range(1, config.SHOP_PRICE_OCR_RETRIES + 1):
price = detector.read_int(_price_rect(config, row, col))
if price == expected_price:
break
if attempt < config.SHOP_PRICE_OCR_RETRIES:
driver.wait(0.3)
if price != expected_price:
print(f"[shop] '{name}' price read as {price}, expected {expected_price} -- skipping (catalog may have changed)")
skipped.append((name, "price_mismatch"))
continue
x, y = _checkbox_center(config, row, col)
driver.click(x, y)
driver.wait(0.3)
if not _is_checked(driver, config, row, col):
print(f"[shop] '{name}' checkbox did not register as checked -- skipping")
skipped.append((name, "checkbox_not_confirmed"))
continue
selected.append((name, expected_price))
return selected, skipped
def _match_name(name_text, remaining):
"""Resolve an OCR'd cell name to the single `remaining` target it
refers to, preferring an exact match over a substring one.
Real bug (2026-09-17): Common Shop's own tier-naming convention nests
a shorter tier name inside a longer one -- "上級強化珠" (Advanced) is
literally a substring of "最上級強化珠" (Highest), same for
"上級レポート"/"最上級レポート". The original substring-only match
(`next(n for n in remaining if n in name_text or name_text in n)`) had
no preference for an exact match, so scanning a "最上級強化珠" card
while "上級強化珠" was still also in `remaining` could resolve to the
WRONG (shorter) target purely because it happened to iterate first in
dict order -- the subsequent price check then compared against the
wrong target's price, always mismatched, and permanently skipped the
real card every single run. Confirmed live: 最上級強化珠 sat available
at its exact listed price for hours across three separate real runs,
never once bought, while shorter-named siblings bought fine.
An exact match is checked first and always wins outright. The
substring fallback (for a genuinely imperfect OCR read missing/adding
a stray character at the START or END) still exists, but picks the
LONGEST candidate -- the more specific name -- to minimize the same
class of collision.
**Real live under-match, 2026-09-24**: even with a clean, purchasable,
correctly-priced card on screen, several targets still went unmatched
every single pass, forcing an unnecessary scroll (and from there into
the separate scroll-misalignment failure -- see _grid_looks_aligned).
Root-caused with a per-cell verbose trace against the live game: the
OCR noise wasn't just a prefix/suffix character any more -- it was an
INTERNAL corruption breaking contiguity, e.g. '初級レポート' (12,500)
read as '初級レポボート' (a phantom character inserted mid-string) and
'中級強化珠' (40,000) read as '中級化珠' (a real character, '強',
dropped from the middle) -- both stable/repeatable across several
consecutive fresh screenshots of the same still-unclicked cell, not a
one-off flake. Neither direction of plain substring containment can
ever match these: the target string literally does not appear
contiguously inside the corrupted OCR text, or vice versa. A separate
case, '中級レポート' read as '。 日 中級レポー ト', had a plain space
inserted before the final character -- also breaks substring
containment, but is fixed for free by stripping whitespace before any
comparison (real target names never contain spaces).
Fixed with a two-stage fallback: (1) strip whitespace before every
comparison stage above; (2) if plain substring containment still finds
nothing, fall back to whole-string similarity (difflib.SequenceMatcher
ratio) against every remaining candidate, taking the best match if it
clears SIMILARITY_THRESHOLD. Confirmed against this incident's own
real corrupted readings: '初級レポボート' vs '初級レポート' scores
~0.92, '中級化珠' vs '中級強化珠' scores ~0.89 -- both comfortably
above threshold, while unrelated/heavily-garbled reads (e.g. a
genuinely different item's name, or a cell read as pure noise) score
well below it in the same live samples. This is a fallback of last
resort, not a replacement for the stages above: an exact or clean
substring match is always preferred, and this project's usual
price-match safety net still guards the actual purchase regardless of
which stage resolved the name.
"""
if not name_text:
return None
normalized = "".join(name_text.split())
if normalized in remaining:
return normalized
candidates = [n for n in remaining if n in normalized or normalized in n]
if candidates:
return max(candidates, key=len)
best_name, best_ratio = None, 0.0
for n in remaining:
ratio = difflib.SequenceMatcher(None, normalized, n).ratio()
if ratio > best_ratio:
best_name, best_ratio = n, ratio
return best_name if best_ratio >= SIMILARITY_THRESHOLD else None
def _scan_current_view(driver, config, remaining):
"""One pass over the currently-visible grid (no scrolling), buying at
most one still-wanted target and returning its name, or None if nothing
in `remaining` matched anywhere on screen right now.
Deliberately stops and returns after the FIRST successful buy rather
than continuing the row/col loop -- see select_targets_by_name's
docstring for why: buying can reflow the grid mid-pass, and continuing
with the old loop's positions after that happens is exactly what caused
a real live under-purchase (2026-09-17).
"""
n_rows = len(config.SHOP_ITEM_ROW_Y)
n_cols = len(config.SHOP_ITEM_COL_X)
for row in range(n_rows):
for col in range(n_cols):
name_text = detector.read_text(_name_rect(config, row, col), lang="jpn")
match = _match_name(name_text, remaining)
if match is None:
continue
price = detector.read_int(_price_rect(config, row, col))
if price != remaining[match]:
continue
if not _is_purchasable(driver, config, row, col):
continue
x, y = _checkbox_center(config, row, col)
driver.click(x, y)
driver.wait(0.3)
if not _is_checked(driver, config, row, col):
print(f"[shop] '{match}' checkbox did not register as checked -- skipping")
continue
# Extra settle time before the caller's next rescan -- a real
# live run (2026-09-17) still missed two further targets that
# were confirmed sitting available minutes later, even with the
# same-pass reflow fix above; the checkbox itself registers
# "checked" well before the grid's own reflow/collapse animation
# visually finishes resettling every other card's position, so
# an immediate rescan can OCR a still-mid-transition frame and
# misread a genuinely-present target as absent.
driver.wait(config.SHOP_REFLOW_SETTLE_WAIT)
return match
return None
def _grid_looks_aligned(driver, config):
"""True if at least one of the 8 fixed grid cells currently reads
purchasable -- a cheap proxy for "the fixed SHOP_ITEM_ROW_Y/
SHOP_ITEM_COL_X crops are actually landing on real cards right now",
not a torn mid-scroll frame.
Real live bug (2026-09-21): a real cron run of Common Shop logged 4-5
of 8 configured targets as "not found available at its expected price"
-- '中級強化珠' among them -- even though a read-only diagnostic probe
against the very same live screen, moments apart, found it sitting
unscrolled at the top of the grid with its correct name, correct price,
and a purchasable buy button. Root-caused with a before/after screenshot
of a single select_targets_by_name scroll call: the grid visibly moved
by something closer to 1.5-2 rows, not the clean single row
SHOP_SCROLL_STEP_CLICKS's own docstring assumed -- landing on a frame
with card titles cut off above the viewport and buy buttons sitting
nowhere near their calibrated offsets. Every fixed-offset OCR/color read
against that frame came back empty or garbled, and _is_purchasable read
False for all 8 cells (vs. 7-8/8 True on a genuinely aligned frame, e.g.
the very first unscrolled screenshot of the same run) -- so the scan
silently treated a real, available item as gone rather than as "my own
crop coordinates are pointing at nothing right now".
Not foolproof: a row that is genuinely, simultaneously sold out across
all 8 visible cells would also read this way. Accepted as an unlikely
edge case, consistent with this module's other scan heuristics (e.g.
select_targets_by_name's own "screenshot unchanged" bottom-of-list
check has a similar blind spot).
"""
n_rows = len(config.SHOP_ITEM_ROW_Y)
n_cols = len(config.SHOP_ITEM_COL_X)
return any(
_is_purchasable(driver, config, row, col)
for row in range(n_rows)
for col in range(n_cols)
)
def _ensure_grid_aligned(driver, config):
"""After a scroll, confirm the grid landed row-aligned (see
_grid_looks_aligned); if not, nudge back up in small steps until it is,
or give up after config.SHOP_SCROLL_REALIGN_MAX_NUDGES attempts.
Returns True once aligned (including if it already was), False if every
nudge was exhausted without recovering.
"""
if _grid_looks_aligned(driver, config):
return True
for _ in range(config.SHOP_SCROLL_REALIGN_MAX_NUDGES):
driver.scroll(*config.SHOP_SCROLL_POINT, "up", clicks=config.SHOP_SCROLL_REALIGN_NUDGE_CLICKS)
driver.wait(0.3)
if _grid_looks_aligned(driver, config):
return True
return False
def select_targets_by_name(driver, config, targets, *, balance_rect):
"""Name-OCR-based sibling of select_targets, for grids where a bought
(or sold-out) item sinks to the bottom and shifts everything else's
position (see this module's own docstring and config.SHOP_PRICE_OCR_OFFSET's
comment for the live incident this was built from). `targets` is a list
of (name, expected_price) pairs, no row/col.
Scans from the top of the (scrollable) grid, two rows per screenshot,
OCR-reading each cell's item name. A cell is bought only if its name
matches a not-yet-found target AND its price OCR matches that target's
exact expected_price -- so an escalated repeat-purchase tier of the
same item (confirmed live: exactly 2x price once the base tier sells
out) is deliberately never matched, same "skip rather than overspend"
call the user made for this project's other targets -- AND its buy
button reads purchasable (not sold out). Scrolls by exactly one row
(config.SHOP_SCROLL_STEP_CLICKS) between reads and stops once every
target is found, the grid stops producing new content (real bottom),
or config.SHOP_NAME_SCAN_MAX_STEPS is hit, whichever comes first.
Matches by substring either direction rather than exact equality, same
tolerance-for-a-stray-character margin story_sweep's own OCR text
matching uses (`"掃討" in text`) -- a clean short UI label is usually
exact, but this doesn't hard-fail on one stray/missing character.
**Real live under-purchase, 2026-09-17**: a real cron run bought only 4
of 8 configured targets, logging the other 4 as "not found available" --
but hours later, with nothing else having touched the account, those
exact 4 items were sitting unbought at their exact expected prices right
at the top of the (unscrolled) grid. Root-caused (with the user's own
pasted log as the key evidence, cross-checked against the successfully
bought items' prices summing exactly to the run's own logged total
spend) to a same-pass reflow bug: the OLD version of this function kept
iterating its row/col loop with the SAME screenshot-implied positions
after a successful buy, even though buying an item collapses its grid
slot and shifts every later item forward -- so a still-wanted item that
got shifted into an already-visited position was silently skipped for
that pass, and the outer loop's unconditional forward-only scroll then
moved the viewport away from it, orphaning it for the rest of the run.
Fixed by re-scanning the CURRENT (unscrolled) view from scratch via
`_scan_current_view` after every single successful buy -- each call
re-reads every cell fresh, so a reflow can't leave a stale match
unnoticed. Scrolling only happens once a full pass finds nothing left
to buy on the current screen.
**Real live false-unavailable, 2026-09-22**: a real cron run logged all
8 targets as "not found available" within 3 seconds of opening the tab
-- far too fast for a real multi-row OCR scan, and a stark outlier
against every other run's 5-10+ second scan time. Root-caused live by
reproducing the same account state interactively: an in-game "network
access problem" dialog (a real, first-party modal, distinct from
anything this project's own code triggers) can appear over the shop
grid at essentially any point -- confirmed live when one appeared while
manually replaying this exact function's own logic step by step. Once
up, it dims the whole grid behind it, so every fixed-offset OCR/color
read comes back empty or garbled, and a STATIC dialog doesn't animate
frame to frame -- so the very next iteration's "screenshot unchanged"
check fires almost immediately, misreporting every remaining target as
genuinely unavailable in a couple of seconds flat, exactly matching the
live log. Fixed by checking `navigation.is_modal_open` (the same
screen-dimming probe used throughout this project, e.g.
`navigation.return_to_home`'s own `_not_home` check) at the top of each
scan pass, before trusting anything read from that frame. Deliberately
does NOT try to dismiss the dialog itself: this specific dialog's own
"OK" button logs all the way out to the title screen, and a different
unrecognized modal could hide something worse (e.g. a real-currency
confirm) -- guessing a keypress here trades a loud, honest stop for a
silent misreport, or worse, an unintended action. Skipped targets get a
distinct 'blocked_by_modal' reason instead of the normal "not found
available", so a run cut short this way is never confused with the
genuinely-benign sold-out/escalated-price case in the log or by anyone
reading it later.
**Real live OCR instability, 2026-09-24**: even with the fixes above,
the exact same still-visible, still-purchasable, still-unscrolled cell
would sometimes read cleanly and sometimes come back corrupted --
confirmed live across five consecutive selection-only test runs (never
clicking Buy, so free to repeat) that which of the 8 targets failed to
match varied run to run, not a fixed set tied to one item's name. A
single full-pass "nothing matched" was previously treated as proof the
remaining targets weren't in the current view at all, immediately
triggering a scroll -- compounding the problem, since scrolling has its
own separate fragility (see _grid_looks_aligned). First fix attempt:
retry a "nothing matched" pass up to `config.SHOP_NO_MATCH_RETRIES`
times, waiting between attempts, before giving up and scrolling.
**That in-place retry turned out not to work, confirmed live the same
session**: reading the exact same still-unclicked cell 5 times in a row
without leaving the shop tab gave the identical wrong text every time
(e.g. '中級化珠' for '中級強化珠', all 5 reads) -- the corruption is
stable for as long as the tab stays open, not a per-frame flake, so
re-reading in place can never see anything different. Fully leaving and
re-entering the shop tab, by contrast, gave a DIFFERENT reading on
4 of 5 attempts in the same live test (one of them exactly correct) --
proving the render itself resets on each fresh tab-open, even though it
doesn't change while sitting on it. Fixed by escalating to a full
return-to-home-and-reopen cycle (bounded by
`config.SHOP_REOPEN_MAX_ATTEMPTS`) once the in-place retries are
exhausted, before ever falling back to scrolling -- most of that live
test's reopen variants (e.g. '中級衝化珠', '中級測化珠', both a single
substituted character) already clear `_match_name`'s fuzzy-similarity
threshold on their own, so a reopen or two is normally enough. A
successful match resets `reopen_attempts` back to 0, so a later,
unrelated stuck target still gets its own full budget.
**Real live under-purchase, 2026-09-24, same day**: leaving the shop
tab does not just reset the render -- it also unchecks every checkbox
already ticked this call, since checked state lives in the tab's own
UI, not the account, until Buy is actually clicked. The first version
of the reopen fix above didn't account for this: a real cron-triggered
run logged all 8 targets as matched (zero skips, `selected` summing to
the full 1,211,500) after one reopen mid-scan, yet the real purchase
only deducted 125,000 -- exactly one target's price, the one found
right after that reopen. Every target confirmed-checked *before* the
reopen had silently gone back to unchecked in the live game, but
`selected` still listed them as done, so confirm_purchase clicked Buy
against a cart that was actually down to one item. Confirmed via the
account's own real credit balance delta.
**First fix (moving already-selected entries back into `remaining` on
every reopen) was correct but pathological**: it eliminated the
under-purchase, but since a reopen now had to re-earn EVERY target
checked so far, not just the one that got stuck, one flaky match
anywhere could force the whole session to redo several already-solved
targets -- confirmed live: a real run cycled through 20+ consecutive
reopens (each one individually reasonable) chasing a shrinking-then-
growing batch, and burned enough wall-clock time doing so that it
eventually collided with a real scheduled `q4h` cron fire on the same
game window, corrupting screenshots for both processes and crashing.
**Real fix: buy each batch before it can be invalidated**, rather than
holding the whole cart in memory across a reopen. `current_batch`
(this session's checked-but-not-yet-bought items) is committed via a
real, balance-verified `confirm_purchase` call -- exactly like a normal
end-of-run purchase, just potentially several times per call instead of
once -- immediately before any reopen, and once more at the very end.
A committed batch moves into `purchased` and can never be undone by a
later reopen, since the real account balance already reflects it. This
function now owns its own purchase confirmation end-to-end (hence the
required `balance_rect` and the `HANDLES_OWN_PURCHASE` flag below) --
`run_shop_tab` no longer buys on this path's behalf. If a batch
purchase itself fails to verify, scanning stops immediately (further
spending on top of an already-unclear balance state would only make a
manual check harder), and every still-remaining target is reported
with a distinct 'unrecognized_state' reason rather than the
genuinely-benign "not found available".
"""
remaining = {name: price for name, price in targets}
current_batch = []
purchased = []
prev_shot = None
blocked_by_modal = False
purchase_failed = False
scroll_steps = 0
reopen_attempts = 0
def commit_current_batch():
"""Buy whatever's checked right now, before anything (a reopen) can
invalidate it. Returns False if the purchase itself doesn't verify
(see confirm_purchase) -- a real, distinct failure from "nothing to
buy", which the caller must stop on rather than paper over."""
nonlocal current_batch, purchase_failed
if not current_batch:
return True
balance_before = detector.read_int(balance_rect)
if balance_before is None:
print("[shop] could not read balance before committing this batch -- stopping without buying")
purchase_failed = True
return False
spent = sum(price for _, price in current_batch)
if not confirm_purchase(driver, config, balance_rect=balance_rect, balance_before=balance_before, expected_spend=spent):
print(f"[shop] purchase confirmation for this batch ({len(current_batch)} item(s), {spent}) did not resolve to a verified balance change -- stopping, check the game manually")
purchase_failed = True
return False
print(f"[shop] bought {len(current_batch)} item(s) for {spent} this batch: {[name for name, _ in current_batch]}")
purchased.extend(current_batch)
current_batch = []
return True
while scroll_steps < config.SHOP_NAME_SCAN_MAX_STEPS:
if not remaining:
break
if navigation.is_modal_open(driver):
print("[shop] an unexpected dialog is covering the shop grid -- stopping scan rather than reading a blocked frame as 'nothing available' (not dismissed automatically: this project doesn't guess how to close an unrecognized modal, since the wrong keypress here can log out or spend real currency)")
blocked_by_modal = True
break
shot = driver.read_screenshot(detector.OCR_SHOT_PATH)
if prev_shot is not None and (shot == prev_shot).all():
print("[shop] grid stopped scrolling -- reached the real bottom of the list")
break
prev_shot = shot
no_match_streak = 0
stuck = False
while remaining:
match = _scan_current_view(driver, config, remaining)
if match is None:
no_match_streak += 1
if no_match_streak < config.SHOP_NO_MATCH_RETRIES:
driver.wait(0.5)
continue
stuck = True
break
no_match_streak = 0
reopen_attempts = 0
current_batch.append((match, remaining.pop(match)))
if not remaining:
break
if stuck and reopen_attempts < config.SHOP_REOPEN_MAX_ATTEMPTS:
reopen_attempts += 1
print(f"[shop] no match after {config.SHOP_NO_MATCH_RETRIES} in-place rescans -- reopening the shop tab for a fresh render (attempt {reopen_attempts}/{config.SHOP_REOPEN_MAX_ATTEMPTS})")
if not commit_current_batch():
break
navigation.return_to_home(driver)
driver.click(*config.SHOP_ICON)
driver.wait(2)
driver.click(*config.SHOP_TAB_COMMON)
driver.wait(1.5)
prev_shot = None
continue
driver.scroll(*config.SHOP_SCROLL_POINT, "down", clicks=config.SHOP_SCROLL_STEP_CLICKS)
driver.wait(0.3)
scroll_steps += 1
if not _ensure_grid_aligned(driver, config):
print("[shop] grid scroll landed on a misaligned frame and could not realign -- stopping scan early (remaining targets may still be genuinely available)")
break
if not purchase_failed:
commit_current_batch()
skipped = []
for name in remaining:
if purchase_failed:
print(f"[shop] '{name}' scan stopped after a batch purchase failed to verify -- NOT confirmed unavailable, check the game manually")
skipped.append((name, "unrecognized_state"))
elif blocked_by_modal:
print(f"[shop] '{name}' scan aborted by a blocking dialog -- NOT confirmed unavailable, check the game manually")
skipped.append((name, "blocked_by_modal"))
else:
print(f"[shop] '{name}' not found available at its expected price {remaining[name]} -- skipping (sold out this cycle, or catalog changed)")
skipped.append((name, "not_available"))
return purchased, skipped
select_targets_by_name.HANDLES_OWN_PURCHASE = True
def confirm_purchase(driver, config, *, balance_rect, balance_before, expected_spend):
"""Click the bulk Buy button, then click through the purchase-confirm
dialog and the reward-acquired banner. Both dim
config.SHOP_OVERLAY_PROBE away from pure white; press Enter until it
reads idle again, bounded by config.SHOP_PURCHASE_MAX_ENTER_PRESSES --
this project doesn't press keys past a bound against an unrecognized
state (see navigation.wait_for_state).
Real live false positive (2026-09-19): the overlay can already read
"idle" on the very first check -- there's nothing in a single
overlay-darkness read that distinguishes "confirmed and closed" from
"the Buy click missed and the confirm dialog never opened at all".
Confirmed live: a real cron run logged "bought 4 item(s)" for a real
credit amount, but those exact 4 items were still sitting unbought at
their base price hours later -- the overlay had simply never dimmed at
any point this function actually checked it. Fixed by also requiring
the currency balance to have actually dropped by `expected_spend`
once the overlay reports idle -- re-read with the same
stray-misread-digit retry tolerance SHOP_PRICE_OCR_RETRIES already uses
elsewhere in this module, so one bad OCR frame on the balance itself
can't sink an otherwise-real purchase.
Returns True only once the overlay is idle AND the balance dropped by
exactly `expected_spend`; False otherwise -- whether the overlay never
cleared within the retry bound, or it cleared but the balance never
moved (or moved by some other amount), meaning nothing was really
bought despite looking "idle".
"""
driver.click(*config.SHOP_BUY_BUTTON)
driver.wait(1.5)
min_ch = config.SHOP_OVERLAY_IDLE_MIN_CHANNEL
idle = False
for _ in range(config.SHOP_PURCHASE_MAX_ENTER_PRESSES):
r, g, b = driver.color_at(*config.SHOP_OVERLAY_PROBE)
if r > min_ch and g > min_ch and b > min_ch:
idle = True
break
driver.keypress("Return")
driver.wait(1.5)
if not idle:
return False
balance_after = None
for attempt in range(1, config.SHOP_PRICE_OCR_RETRIES + 1):
balance_after = detector.read_int(balance_rect)
if balance_after is not None and balance_before - balance_after == expected_spend:
return True
if attempt < config.SHOP_PRICE_OCR_RETRIES:
driver.wait(0.3)
actual_spend = None if balance_after is None else balance_before - balance_after
print(f"[shop] purchase overlay cleared but balance changed by {actual_spend}, expected {expected_spend} -- treating as not confirmed")
return False
def run_shop_tab(driver, config, *, tab_button, targets, balance_rect, currency_label, select_fn=select_targets):
"""Shared control flow for both shop tabs: open the tab, verify enough
currency for everything configured, select+buy, report the outcome.
Ported from the reference's common_shop.py/tactical_challenge_shop.py
implement() -- both are this same shape (read assets, calculate cost,
buy, verify), differing only in tab entry point and currency.
`select_fn` defaults to the position-based select_targets (Tactical
Shop's own (row, col, name, price) targets); shop_common.py passes
select_targets_by_name instead, for its (name, price) targets -- see
that function's docstring for why Common Shop needs name-based
identification specifically.
`select_fn` normally only selects (checkbox state); this function buys
once at the end. select_targets_by_name is the one exception, flagged
via its own `HANDLES_OWN_PURCHASE` attribute -- it needs to buy
incrementally in its own batches (see its docstring's 2026-09-24
entries for why one end-of-scan purchase isn't safe for it), so this
function defers to whatever it already bought instead of buying again.
"""
if not targets:
print(f"[shop] no targets configured for {currency_label}, nothing to do")
return "no_targets"
driver.click(*tab_button)
driver.wait(1.5)
if not navigation.is_on_subscreen(driver):
print("[shop] could not confirm shop tab opened, aborting without pressing further keys")
return "navigation_failed"
balance = detector.read_int(balance_rect)
if balance is None:
print(f"[shop] could not read {currency_label} balance, aborting without spending")
return "balance_unreadable"
total_cost = sum(target[-1] for target in targets)
if balance < total_cost:
print(f"[shop] insufficient {currency_label}: have {balance}, need {total_cost} -- stopping, nothing bought")
return "inadequate_assets"
if getattr(select_fn, "HANDLES_OWN_PURCHASE", False):
# select_targets_by_name buys as it goes (possibly in several
# batches, each independently balance-verified) rather than
# returning an unbought selection for this function to purchase in
# one shot -- see that function's own docstring for why a single
# end-of-scan purchase isn't safe for it. `purchased` below is
# already real, confirmed spending, not a pending cart.
purchased, skipped = select_fn(driver, config, targets, balance_rect=balance_rect)
if not purchased:
if any(reason == "unrecognized_state" for _, reason in skipped):
print("[shop] a batch purchase failed to verify partway through -- stopping, check the game manually")
return "unrecognized_state"
print("[shop] nothing purchased (all targets skipped)")
return "nothing_selected"
spent = sum(price for _, price in purchased)
msg = f"[shop] bought {len(purchased)} item(s) for {spent} {currency_label}"
if skipped:
msg += f", skipped {len(skipped)}"
print(msg)
return "purchased"
selected, skipped = select_fn(driver, config, targets)
if not selected:
print("[shop] nothing selected (all targets skipped), cancelling")
return "nothing_selected"
spent = sum(price for _, price in selected)
if not confirm_purchase(driver, config, balance_rect=balance_rect, balance_before=balance, expected_spend=spent):
print("[shop] purchase confirmation did not resolve to a verified balance change within the retry bound -- stopping, check the game manually")
return "unrecognized_state"
msg = f"[shop] bought {len(selected)} item(s) for {spent} {currency_label}"
if skipped:
msg += f", skipped {len(skipped)}"
print(msg)
return "purchased"