348 lines
15 KiB
Python
348 lines
15 KiB
Python
"""Cafe daily task. Ported from baas-reference module/cafe_reward.py's state-probe pattern.
|
|
|
|
Student invitation (招待券), added 2026-07-14 per explicit user direction,
|
|
ports module/cafe_reward.py's invite_girl/invite_by_affection/
|
|
checkConfirmInvite: invite a student into each room before farming it (a
|
|
newly-invited student can be patted the same run), preferring the
|
|
HIGHEST-affection candidate among the first 5 visible in the MomoTalk list
|
|
(matching the reference's own invite_by_affection bound -- no scrolling),
|
|
and always skipping (never confirming) a candidate that would swap an
|
|
already-seated student's costume or move one in from the other room. This
|
|
directly ports the reference's own checkConfirmInvite behavior with its
|
|
default config (cafe_reward_allow_exchange_student/
|
|
cafe_reward_allow_duplicate_invite both False) -- there is no equivalent
|
|
config in this project to make either configurable, so both are always
|
|
disallowed. See config.py's "Cafe student invitation" section for the full
|
|
live-calibration writeup, including all 3 real dialog variants this was
|
|
confirmed against (zero real tickets spent during calibration).
|
|
|
|
Confirmed live with real tickets spent, both rooms, same day: room 1
|
|
correctly skipped one 衣装替え (costume-swap) candidate then invited row 1
|
|
cleanly; room 2 correctly skipped three consecutive 隣のカフェの生徒を招待
|
|
(neighboring-room-move) candidates -- expected, since room 1's own invite
|
|
had just taken the account's highest-affection students -- then invited
|
|
row 3 cleanly. Both newly-invited students were immediately patted
|
|
successfully in the same run, income was claimed, and the task returned
|
|
cleanly to the true home screen with no warnings anywhere in the log.
|
|
|
|
A follow-up real-usage bug (2026-07-14, reported with a screenshot after
|
|
the ticket used above went on cooldown): _open_invite_list originally
|
|
verified only "did the header stop reading as a plain subscreen", which
|
|
is also true when the ticket is on cooldown and the click raises a
|
|
"通知" notice ("待機時間が経過した後に、再度招待することができます。")
|
|
directly instead of opening the list -- misread as "list opened", it then
|
|
sent _ensure_invite_sort/_try_invite_row's row/sort-control coordinates
|
|
into a dialog that has none of them, repeatedly. Fixed by checking
|
|
navigation.is_modal_open (a real dialog's darker dim) before the
|
|
list-opened check: a dialog appearing before any row was clicked can only
|
|
mean the ticket click itself raised one directly, so this now dismisses
|
|
it via SWEEP_CONFIRM_BUTTON and returns False (skip invite this room)
|
|
instead of proceeding.
|
|
"""
|
|
|
|
from ba_auto import detector, navigation
|
|
|
|
ROOM_OPEN_RETRIES = 3
|
|
|
|
# "受取" (claim) renders as flat grey when there is nothing to collect yet.
|
|
CLAIM_PROBE = (960, 850)
|
|
CLAIM_DISABLED_RGB = (218, 218, 218)
|
|
CLAIM_DISABLED_TOLERANCE = 15
|
|
|
|
|
|
def _claim_disabled(driver):
|
|
r, g, b = driver.color_at(*CLAIM_PROBE)
|
|
tr, tg, tb = CLAIM_DISABLED_RGB
|
|
return (
|
|
abs(r - tr) <= CLAIM_DISABLED_TOLERANCE
|
|
and abs(g - tg) <= CLAIM_DISABLED_TOLERANCE
|
|
and abs(b - tb) <= CLAIM_DISABLED_TOLERANCE
|
|
)
|
|
|
|
|
|
def _enter_room(driver, coords):
|
|
for attempt in range(1, ROOM_OPEN_RETRIES + 1):
|
|
driver.click(*coords)
|
|
driver.wait(3)
|
|
if navigation.is_on_subscreen(driver):
|
|
# dismiss the "visited student list" notice shown on room entry
|
|
driver.keypress("Return")
|
|
driver.wait(1)
|
|
return True
|
|
print(f"[cafe] room not detected after click (attempt {attempt}/{ROOM_OPEN_RETRIES})")
|
|
return False
|
|
|
|
|
|
def _dismiss_rank_up_if_shown(driver, config):
|
|
# The reference's own to_cafe() navigation (module/cafe_reward.py) treats
|
|
# 'relationship_rank_up' as a recognized, reactively-dismissed popup
|
|
# after every pat round -- this loop's original port had no equivalent,
|
|
# so a rank-up cutscene just sat there while find_cafe_sparkle() kept
|
|
# returning None against it (a full-screen character portrait, nothing
|
|
# like the sparkle template) for the rest of the room's click budget.
|
|
# That's the "freeze" -- not a timing fluke, a genuinely unhandled state.
|
|
for _ in range(config.CAFE_RANK_UP_DISMISS_RETRIES):
|
|
if navigation.is_on_subscreen(driver):
|
|
return True
|
|
driver.keypress("Return")
|
|
driver.wait(1.5)
|
|
return navigation.is_on_subscreen(driver)
|
|
|
|
|
|
def _pat_current_view(driver, config):
|
|
# Sparkles appear on a per-student cooldown, so most single checks find
|
|
# nothing -- the old Bash loop (and an earlier version of this one) gave
|
|
# up on the very first miss, which meant it essentially never farmed.
|
|
# Keep polling for the full budget instead of bailing early.
|
|
patted = 0
|
|
for _ in range(config.CAFE_MAX_CLICKS_PER_ROOM):
|
|
match = detector.find_cafe_sparkle()
|
|
if match is None:
|
|
driver.wait(1)
|
|
continue
|
|
x, y, score = match
|
|
driver.click(x, y)
|
|
driver.wait(1)
|
|
driver.keypress("Return")
|
|
# park the cursor away from the sparkle area so it can't occlude the
|
|
# next detection screenshot (see screenshots/cafe/sparkle/02_*_cursor_on_head.png)
|
|
driver.move_mouse(10, 1190)
|
|
if not _dismiss_rank_up_if_shown(driver, config):
|
|
print("[cafe] warning: cafe screen not confirmed after a pat (rank-up cutscene stuck?) -- stopping this view's pat loop rather than clicking blindly")
|
|
break
|
|
patted += 1
|
|
print(f"[cafe] patted sparkle at ({x}, {y}), score={score:.3f}")
|
|
return patted
|
|
|
|
|
|
def _pan_camera(driver, config, start_x, end_x):
|
|
for _ in range(config.CAFE_PAN_DRAG_REPEATS):
|
|
driver.drag(start_x, config.CAFE_PAN_DRAG_Y, end_x, config.CAFE_PAN_DRAG_Y, duration=config.CAFE_PAN_DRAG_DURATION)
|
|
driver.wait(0.5)
|
|
|
|
|
|
def _pat_room(driver, config):
|
|
# Per explicit user direction (2026-07-14): the room is wider than what
|
|
# fits in one view on the user's screen, so a stationary scan can miss
|
|
# students sitting outside whatever slice happened to be visible when
|
|
# the room loaded. Pans the camera to its rightmost extreme, farms
|
|
# there, then to its leftmost extreme, farms there too -- deliberately
|
|
# no vertical pan, per the user's own instruction that it would mess
|
|
# with the view. See config.py's "Horizontal camera panning" comment
|
|
# for the live-confirmed drag-direction-to-reveal-side mapping.
|
|
total_patted = 0
|
|
|
|
_pan_camera(driver, config, config.CAFE_PAN_RIGHT_X, config.CAFE_PAN_LEFT_X)
|
|
print("[cafe] panned to rightmost extreme")
|
|
total_patted += _pat_current_view(driver, config)
|
|
|
|
_pan_camera(driver, config, config.CAFE_PAN_LEFT_X, config.CAFE_PAN_RIGHT_X)
|
|
print("[cafe] panned to leftmost extreme")
|
|
total_patted += _pat_current_view(driver, config)
|
|
|
|
print(f"[cafe] patted {total_patted} sparkle(s) total" if total_patted else "[cafe] no sparkle found")
|
|
|
|
|
|
def _claim_income(driver, config):
|
|
driver.click(*config.CAFE_INCOME)
|
|
driver.wait(2)
|
|
if not navigation.is_modal_open(driver):
|
|
print("[cafe] income panel not detected, skipping claim")
|
|
return
|
|
|
|
if _claim_disabled(driver):
|
|
print("[cafe] nothing to claim")
|
|
else:
|
|
print("[cafe] claiming income")
|
|
driver.keypress("Return")
|
|
driver.wait(2)
|
|
driver.keypress("Return")
|
|
driver.wait(2)
|
|
|
|
if navigation.is_modal_open(driver):
|
|
driver.keypress("Escape")
|
|
driver.wait(1.5)
|
|
|
|
|
|
def _open_invite_list(driver, config):
|
|
# The MomoTalk list's own dimming overlay darkens navigation.
|
|
# is_on_subscreen's header probe the same way any subscreen-covering
|
|
# modal does (see navigation.py's own _not_home docstring for the
|
|
# general version of this) -- checked directly rather than via
|
|
# navigation.is_modal_open, which needs a darker reading than this
|
|
# list-with-no-nested-dialog state actually produces (confirmed live:
|
|
# MODAL_DIM_PROBE read (252,145,165) with just the list open, which
|
|
# fails is_modal_open's all-channels-under-150 check).
|
|
#
|
|
# But that same "not on subscreen" reading is also produced by a
|
|
# completely different case: when the ticket is on cooldown, clicking
|
|
# the icon does NOT open the list at all -- it raises a "通知" dialog
|
|
# directly ("待機時間が経過した後に、再度招待することができます。",
|
|
# confirmed live 2026-07-14 via a real user report + screenshot) with
|
|
# the same dimming. The original version of this check couldn't tell
|
|
# the two apart and treated the cooldown notice as "list opened",
|
|
# which then sent _ensure_invite_sort/_try_invite_row's fixed row/
|
|
# sort-control coordinates into a dialog that doesn't have any of
|
|
# them -- exactly the "keep pressing the invite when it's not
|
|
# available and causing this popup and fail" the user reported.
|
|
#
|
|
# A real dialog (navigation.is_modal_open, which needs the DARKER
|
|
# reading a nested "通知" card produces, not just the list's own lighter
|
|
# dim) can only legitimately appear here if the ticket click itself
|
|
# opened one directly -- the list view has no dialog on top of it yet
|
|
# at this point, since no row has been clicked. So checking
|
|
# is_modal_open first, before the list-opened check, cleanly
|
|
# distinguishes "cooldown notice fired instead of the list" from "the
|
|
# list opened normally" and lets this dismiss the notice safely rather
|
|
# than misreading it as success.
|
|
for attempt in range(1, ROOM_OPEN_RETRIES + 1):
|
|
driver.click(*config.CAFE_INVITE_TICKET_ICON)
|
|
driver.wait(2)
|
|
if navigation.is_modal_open(driver):
|
|
title = detector.read_text(config.CAFE_INVITE_DIALOG_TITLE_RECT, psm=6, lang="jpn")
|
|
print(f"[cafe] invite ticket click opened a dialog instead of the list (title: '{title}') -- likely on cooldown, treating invitation as unavailable")
|
|
driver.click(*config.SWEEP_CONFIRM_BUTTON)
|
|
driver.wait(1)
|
|
return False
|
|
if not navigation.is_on_subscreen(driver):
|
|
return True
|
|
print(f"[cafe] invitation ticket list not detected after click (attempt {attempt}/{ROOM_OPEN_RETRIES})")
|
|
return False
|
|
|
|
|
|
def _invite_heart_rect(config, row_index):
|
|
row_y = config.CAFE_INVITE_ROW_Y[row_index]
|
|
hx, hy = config.CAFE_INVITE_HEART_OCR_HALF_SIZE
|
|
cx = config.CAFE_INVITE_HEART_X
|
|
return (cx - hx, row_y - hy, cx + hx, row_y + hy)
|
|
|
|
|
|
def _read_invite_affection(driver, config, row_index):
|
|
return detector.read_int_on_heart_badge(_invite_heart_rect(config, row_index))
|
|
|
|
|
|
def _ensure_invite_sort(driver, config):
|
|
# Explicitly (re-)select 絆ランク as the sort field every run, rather
|
|
# than trusting whatever a previous manual session left selected --
|
|
# mirrors the reference's own explicit change_order_type step.
|
|
driver.click(*config.CAFE_INVITE_SORT_FIELD_DROPDOWN)
|
|
driver.wait(1)
|
|
driver.click(*config.CAFE_INVITE_SORT_BOND_RANK_OPTION)
|
|
driver.wait(0.3)
|
|
driver.click(*config.CAFE_INVITE_SORT_OK_BUTTON)
|
|
driver.wait(1)
|
|
|
|
# Per explicit user direction: highest affection first. Rather than
|
|
# reading the direction-toggle icon's own arrow glyph, compare the top
|
|
# two rows' actual OCR'd affection values -- if row 0 reads lower than
|
|
# row 1, the list is sorted ascending and needs one toggle click. Reuses
|
|
# the same OCR path already needed to evaluate candidates, and is
|
|
# confirmed live in both directions (descending: 38,35; ascending: 1,2).
|
|
top = _read_invite_affection(driver, config, 0)
|
|
second = _read_invite_affection(driver, config, 1)
|
|
if top is not None and second is not None and top < second:
|
|
print(f"[cafe] invite list sorted ascending ({top} < {second}) -- toggling to descending")
|
|
driver.click(*config.CAFE_INVITE_SORT_DIRECTION_TOGGLE)
|
|
driver.wait(1)
|
|
|
|
|
|
def _is_swap_or_move_warning(title):
|
|
return "衣装" in title or "隣" in title
|
|
|
|
|
|
def _try_invite_row(driver, config, row_index):
|
|
"""Click a row's 招待 button and resolve whatever dialog appears.
|
|
Returns "invited" (confirmed a real invite), "skipped" (a swap/move
|
|
warning was detected and cancelled without spending anything), or
|
|
"no_dialog" (the click didn't seem to open anything -- treated as a
|
|
miss, not a decision, so the caller stops rather than guess further).
|
|
"""
|
|
row_y = config.CAFE_INVITE_ROW_Y[row_index]
|
|
driver.click(config.CAFE_INVITE_BUTTON_X, row_y)
|
|
driver.wait(1.5)
|
|
if not navigation.is_modal_open(driver):
|
|
print(f"[cafe] invite click on row {row_index} did not open a dialog")
|
|
return "no_dialog"
|
|
|
|
title = detector.read_text(config.CAFE_INVITE_DIALOG_TITLE_RECT, psm=6, lang="jpn")
|
|
print(f"[cafe] row {row_index} invite dialog title: '{title}'")
|
|
if _is_swap_or_move_warning(title):
|
|
print(f"[cafe] row {row_index} would swap an already-seated student's costume or move one in from the other room -- skipping")
|
|
driver.keypress("Escape")
|
|
driver.wait(1.5)
|
|
return "skipped"
|
|
|
|
driver.click(*config.SWEEP_CONFIRM_BUTTON)
|
|
driver.wait(2)
|
|
return "invited"
|
|
|
|
|
|
def _invite_student(driver, config):
|
|
"""Invite the highest-affection available student into the current
|
|
room, before farming it. Tries up to len(CAFE_INVITE_ROW_Y) visible
|
|
candidates (matching the reference's own invite_by_affection bound --
|
|
no scrolling), stopping at the first one that invites cleanly; skips
|
|
(never confirms) any candidate that would swap an already-seated
|
|
student's costume or move one in from the other room.
|
|
"""
|
|
if not _open_invite_list(driver, config):
|
|
print("[cafe] could not open the invitation ticket list -- no ticket available or a click missed, skipping invite")
|
|
return
|
|
|
|
_ensure_invite_sort(driver, config)
|
|
|
|
invited = False
|
|
for row_index in range(len(config.CAFE_INVITE_ROW_Y)):
|
|
result = _try_invite_row(driver, config, row_index)
|
|
if result == "invited":
|
|
print(f"[cafe] invited row {row_index}")
|
|
invited = True
|
|
break
|
|
if result == "no_dialog":
|
|
break
|
|
|
|
if not invited:
|
|
print("[cafe] no candidate could be invited without swapping/moving an existing student")
|
|
|
|
# Return to the plain room view regardless of outcome.
|
|
if navigation.is_modal_open(driver):
|
|
driver.keypress("Escape")
|
|
driver.wait(1)
|
|
if not navigation.is_on_subscreen(driver):
|
|
driver.click(*config.CAFE_INVITE_LIST_CLOSE_BUTTON)
|
|
driver.wait(1)
|
|
|
|
|
|
def run(driver, config):
|
|
driver.focus_game()
|
|
|
|
if not _enter_room(driver, config.CAFE_ICON):
|
|
print("[cafe] could not confirm cafe is open, aborting without pressing further keys")
|
|
return
|
|
|
|
print("[cafe] room 1: inviting a student if available")
|
|
_invite_student(driver, config)
|
|
|
|
print("[cafe] room 1: farming affection")
|
|
_pat_room(driver, config)
|
|
|
|
if not _enter_room(driver, config.CAFE_ROOM_SWITCH):
|
|
print("[cafe] could not confirm room switch, stopping before income claim")
|
|
if navigation.is_on_subscreen(driver):
|
|
driver.keypress("Escape")
|
|
driver.wait(1.5)
|
|
return
|
|
|
|
print("[cafe] room 2: inviting a student if available")
|
|
_invite_student(driver, config)
|
|
|
|
print("[cafe] room 2: farming affection")
|
|
_pat_room(driver, config)
|
|
|
|
_claim_income(driver, config)
|
|
|
|
if navigation.is_on_subscreen(driver):
|
|
driver.keypress("Escape")
|
|
driver.wait(1.5)
|
|
print("[cafe] Done.")
|