yml2213
0294606807
- 并发额度下沉到单次请求：runState.sem 只覆盖一次在途请求（列表/兑换/刷新），账号在退避等待期间释放额度；旧实现把额度给整个账号循环，退避中的账号一直霸占额度，账号多时互相饿死 - 售罄不再默认终止：normalizeConfig 去掉 StopOnSoldOut 默认 true，售罄按退避继续探测到轮次结束（别人取消或锁单过期会让库存回流）；CategoryOffShelf 拆成独立分支，下架/不存在仍终止该奖品；删除已无意义的 ContinueOnSoldOut - 退避统一加 0-25% 抖动（jitterDuration，只往上抖，配置值仍是下限），避免多账号在同一时刻整批重试形成周期尖峰 - 新增 Runner.OnSummary/RunSummary：轮次、账号、目标、耗时、列表/兑换/积分/记录请求次数、成功账号数与结局分布（按次数排序），在 refresh.Wait() 之后回调；CLI 与 GUI 各输出一行汇总加逐类结局 - 取消清理：等待额度的账号返回 action=exchange_canceled 且调用方直接返回，停止监控时不再为每个排队账号刷错误结果 - http 传输补连接池参数（MaxConnsPerHost=64、MaxIdleConns=128、MaxIdleConnsPerHost=64、IdleConnTimeout=30s），多账号不再反复重建连接 - CLI/GUI 的 waitUntil 从 200ms 轮询改为一次性定时器，消除 0-200ms 随机延迟（正好错过开抢窗口） - GUI 抽出 runnerConfig()，用 ListBeforeExchange=!DirectExchange 表达界面语义，修复「直接兑换」开关失效（旧实现被引擎强制回落直兑，价格/库存过滤不生效） - 测试：sniper 新增售罄继续探测、StopOnSoldOut 即停、下架终止、在途请求数等于并发数、汇总含刷新请求、抖动区间等用例；GUI 新增 runnerConfig 用例；README 补「抢购调度与退避（2026-10-16 调整）」
856 lines
26 KiB
Go
856 lines
26 KiB
Go
package gui
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"fmt"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/wailsapp/wails/v2/pkg/runtime"
|
||
|
||
"huya-go/internal/huya"
|
||
"huya-go/internal/instance"
|
||
"huya-go/internal/logger"
|
||
"huya-go/internal/sniper"
|
||
"huya-go/internal/version"
|
||
)
|
||
|
||
const (
|
||
eventLog = "gui:log"
|
||
eventMonitorResult = "gui:monitor-result"
|
||
eventMonitorState = "gui:monitor-state"
|
||
|
||
// maxLogEntries 内存里保留的日志条数，界面按自增 ID 增量拉取。
|
||
maxLogEntries = 2000
|
||
|
||
// 日志分类，便于在界面上区分应用、网络、监控与账号维度的日志。
|
||
categoryApp = "应用"
|
||
categoryNet = "网络"
|
||
categoryMonitor = "监控"
|
||
)
|
||
|
||
type App struct {
|
||
ctx context.Context
|
||
|
||
// logStore 是内存日志缓冲；界面通过 GetLogs(sinceID) 增量拉取。
|
||
logStore *logger.Store
|
||
// closeLog 由 logger.Init 返回，用于在退出时把异步队列刷盘。
|
||
closeLog func()
|
||
logInitErr error
|
||
|
||
// instanceLease 在 wails.Run 之前由 main 占用并注入（WebView2 目录需要提前确定）。
|
||
instanceLease *instance.Lease
|
||
instanceErr error
|
||
instanceName string
|
||
instanceID string
|
||
dataDir string
|
||
|
||
runMu sync.Mutex
|
||
monitorCancel context.CancelFunc
|
||
monitorRunning bool
|
||
}
|
||
|
||
type Config struct {
|
||
Transport string `json:"transport"`
|
||
WSSHost string `json:"wssHost"`
|
||
SID int32 `json:"sid"`
|
||
PID int32 `json:"pid"`
|
||
// Category 是类目（限量返场/精英专享，或类目 id）：只影响监控时的自动选品范围。
|
||
Category string `json:"category"`
|
||
Name string `json:"name"`
|
||
TargetText string `json:"targetText"`
|
||
MaxPrice int64 `json:"maxPrice"`
|
||
MinLeft int64 `json:"minLeft"`
|
||
CookieText string `json:"cookieText"`
|
||
SelectedAccountLines []int `json:"selectedAccountLines"`
|
||
Loops int `json:"loops"`
|
||
DelayMS int `json:"delayMs"`
|
||
Concurrency int `json:"concurrency"`
|
||
StopAfterSuccess bool `json:"stopAfterSuccess"`
|
||
StopAccountAfterSuccess bool `json:"stopAccountAfterSuccess"`
|
||
Prewarm bool `json:"prewarm"`
|
||
DirectExchange bool `json:"directExchange"`
|
||
SharePrizeList bool `json:"sharePrizeList"`
|
||
AutoSelect bool `json:"autoSelect"`
|
||
RefreshAfterSuccess bool `json:"refreshAfterSuccess"`
|
||
LeadMS int `json:"leadMs"`
|
||
FrequentBackoffMS int `json:"frequentBackoffMs"`
|
||
ErrorBackoffMS int `json:"errorBackoffMs"`
|
||
TimeoutSec int `json:"timeoutSec"`
|
||
StartAt string `json:"startAt"`
|
||
}
|
||
|
||
type AccountPreview struct {
|
||
Line int `json:"line"`
|
||
UID int64 `json:"uid"`
|
||
Valid bool `json:"valid"`
|
||
Error string `json:"error,omitempty"`
|
||
}
|
||
|
||
// LogStats 描述当前日志运行时状态，供界面展示与排查。
|
||
type LogStats struct {
|
||
Level string `json:"level"`
|
||
FilePath string `json:"filePath"`
|
||
Dir string `json:"dir"`
|
||
Dropped uint64 `json:"dropped"`
|
||
Count int `json:"count"`
|
||
}
|
||
|
||
// InstanceInfo 描述当前进程占用的实例，供界面展示与本地存储分片。
|
||
type InstanceInfo struct {
|
||
Name string `json:"name"`
|
||
ID string `json:"id"`
|
||
DataDir string `json:"dataDir"`
|
||
LogDir string `json:"logDir"`
|
||
LogFile string `json:"logFile"`
|
||
}
|
||
|
||
type PrizeListResult struct {
|
||
UID int64 `json:"uid"`
|
||
Status int32 `json:"status"`
|
||
Msg string `json:"msg"`
|
||
Prizes []huya.PrizeInfo `json:"prizes"`
|
||
// Categories 是服务端下发的类目字典（限量返场/精英专享），CategoryStats 是对应的商品数统计。
|
||
Categories []huya.PrizeTag `json:"categories"`
|
||
CategoryStats []huya.CategoryStat `json:"categoryStats"`
|
||
Raw *huya.GetActPrizeListResp `json:"raw,omitempty"`
|
||
}
|
||
|
||
type ScoreResult struct {
|
||
UID int64 `json:"uid"`
|
||
Score int64 `json:"score"`
|
||
Resp *huya.GetUserScoreResp `json:"resp,omitempty"`
|
||
Error string `json:"error,omitempty"`
|
||
}
|
||
|
||
type RecordResult struct {
|
||
UID int64 `json:"uid"`
|
||
Records []huya.UserPrizeInfo `json:"records"`
|
||
Resp *huya.GetUserPrizeRecordsResp `json:"resp,omitempty"`
|
||
Error string `json:"error,omitempty"`
|
||
}
|
||
|
||
type ExchangeResult struct {
|
||
UID int64 `json:"uid"`
|
||
Resp *huya.ScoreExchangePrizeResp `json:"resp,omitempty"`
|
||
Category string `json:"category,omitempty"`
|
||
Message string `json:"message,omitempty"`
|
||
Error string `json:"error,omitempty"`
|
||
}
|
||
|
||
type MonitorState struct {
|
||
Running bool `json:"running"`
|
||
Message string `json:"message"`
|
||
}
|
||
|
||
type cookieLine struct {
|
||
lineNo int
|
||
text string
|
||
}
|
||
|
||
// NewApp 创建 App 实例。lease 由 main 在 wails.Run 之前占用并注入。
|
||
//
|
||
// 为什么要在 wails.Run 之前占位：WebView2 的用户数据目录必须在创建窗口之前确定，
|
||
// 而它必须按实例区分（见 instance.Lease.WebviewUserDataDir）。
|
||
// 用构造器参数而不是导出的 setter，是为了避免它被 Wails 当成前端可调用方法生成绑定。
|
||
func NewApp(lease *instance.Lease, instanceErr error) *App {
|
||
return &App{instanceLease: lease, instanceErr: instanceErr}
|
||
}
|
||
|
||
func (a *App) Startup(ctx context.Context) {
|
||
a.ctx = ctx
|
||
|
||
lease, leaseErr := a.instanceLease, a.instanceErr
|
||
if lease == nil {
|
||
// 其它入口（测试、非 Wails 启动）没有提前占位时在这里补一次。
|
||
lease, leaseErr = instance.Acquire()
|
||
}
|
||
logDir := ""
|
||
if lease != nil {
|
||
a.instanceLease = lease
|
||
a.instanceName = lease.Name()
|
||
a.instanceID = lease.ID()
|
||
a.dataDir = lease.Paths().DataDir
|
||
logDir = lease.Paths().LogDir
|
||
}
|
||
if a.instanceName == "" {
|
||
a.instanceName = "默认实例"
|
||
}
|
||
if a.instanceID == "" {
|
||
a.instanceID = "default"
|
||
}
|
||
|
||
a.logStore = logger.NewStore(maxLogEntries)
|
||
// 日志先注册界面推送，再初始化文件输出，这样启动阶段的日志也能实时到达界面。
|
||
logger.SetEmitter(func(entry logger.Entry) {
|
||
a.emit(eventLog, entry)
|
||
})
|
||
closeLog, logErr := logger.Init(a.logStore, logDir, a.instanceName, a.instanceID, a.dataDir)
|
||
a.closeLog = closeLog
|
||
a.logInitErr = logErr
|
||
|
||
if leaseErr != nil {
|
||
// 数据目录仍然是本实例独享的（临时实例），但隔离能力已降级，必须让人看见。
|
||
logger.LogEvent("系统", logger.LevelWarn, "实例隔离已降级（%s，数据目录仍独立）: %v", a.instanceName, leaseErr)
|
||
} else {
|
||
logger.LogEvent("系统", logger.LevelSuccess, "已启动%s，数据目录: %s", a.instanceName, a.dataDir)
|
||
}
|
||
if logErr != nil {
|
||
logger.LogEvent(categoryApp, logger.LevelWarn, "日志文件不可用，日志仅保留在界面: %v", logErr)
|
||
}
|
||
}
|
||
|
||
// GetLogFilePath 返回当前日志文件路径（供界面展示/复制）。
|
||
func (a *App) GetLogFilePath() string {
|
||
return logger.FilePath()
|
||
}
|
||
|
||
// GetLogs 返回自增 ID 大于 sinceID 的日志，界面据此增量拉取。
|
||
func (a *App) GetLogs(sinceID int64) []logger.Entry {
|
||
if a.logStore == nil {
|
||
return []logger.Entry{}
|
||
}
|
||
return a.logStore.Since(sinceID)
|
||
}
|
||
|
||
// GetLogStats 返回日志运行时状态（等级、文件、丢弃条数）。
|
||
func (a *App) GetLogStats() LogStats {
|
||
return LogStats{
|
||
Level: logger.MinLevel(),
|
||
FilePath: logger.FilePath(),
|
||
Dir: logger.Dir(),
|
||
Dropped: logger.Dropped(),
|
||
Count: a.logStoreCount(),
|
||
}
|
||
}
|
||
|
||
// SetLogLevel 调整日志最低输出等级，返回归一化后的等级。
|
||
func (a *App) SetLogLevel(level string) string {
|
||
normalized := logger.LevelFromString(level)
|
||
logger.SetMinLevel(normalized)
|
||
logger.LogEvent(categoryApp, logger.LevelSuccess, "日志等级已切换为 %s", normalized)
|
||
return normalized
|
||
}
|
||
|
||
// GetInstanceInfo 返回当前实例信息（名称、标识、数据与日志路径）。
|
||
func (a *App) GetInstanceInfo() InstanceInfo {
|
||
name := a.instanceName
|
||
if name == "" {
|
||
name = "默认实例"
|
||
}
|
||
id := a.instanceID
|
||
if id == "" {
|
||
id = "default"
|
||
}
|
||
info := InstanceInfo{Name: name, ID: id, DataDir: a.dataDir, LogFile: logger.FilePath()}
|
||
if a.instanceLease != nil {
|
||
info.LogDir = a.instanceLease.Paths().LogDir
|
||
}
|
||
return info
|
||
}
|
||
|
||
// GetVersion 返回应用版本号（与 exe 文件名、编译期版本号同源）。
|
||
func (a *App) GetVersion() string {
|
||
return version.Display()
|
||
}
|
||
|
||
// OpenLogDir 用系统文件管理器打开日志目录。
|
||
func (a *App) OpenLogDir() error {
|
||
dir := logger.Dir()
|
||
if dir == "" {
|
||
if a.logInitErr != nil {
|
||
return fmt.Errorf("日志目录不可用: %w", a.logInitErr)
|
||
}
|
||
return errors.New("日志目录不可用")
|
||
}
|
||
if err := openDirectory(dir); err != nil {
|
||
return fmt.Errorf("打开日志目录失败: %w", err)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (a *App) logStoreCount() int {
|
||
if a.logStore == nil {
|
||
return 0
|
||
}
|
||
return a.logStore.Count()
|
||
}
|
||
|
||
func (a *App) Shutdown(ctx context.Context) {
|
||
a.StopMonitor()
|
||
logger.SetEmitter(nil)
|
||
if a.closeLog != nil {
|
||
a.closeLog()
|
||
a.closeLog = nil
|
||
}
|
||
if a.instanceLease != nil {
|
||
a.instanceLease.Release()
|
||
a.instanceLease = nil
|
||
}
|
||
}
|
||
|
||
func (a *App) DefaultConfig() Config {
|
||
return Config{
|
||
Transport: "wss",
|
||
WSSHost: "",
|
||
SID: 2203,
|
||
Loops: 20,
|
||
DelayMS: 120,
|
||
Concurrency: 5,
|
||
StopAfterSuccess: false,
|
||
StopAccountAfterSuccess: true,
|
||
Prewarm: true,
|
||
DirectExchange: true,
|
||
SharePrizeList: true,
|
||
AutoSelect: false,
|
||
RefreshAfterSuccess: true,
|
||
LeadMS: 2500,
|
||
FrequentBackoffMS: 300,
|
||
ErrorBackoffMS: 300,
|
||
TimeoutSec: 15,
|
||
}
|
||
}
|
||
|
||
func (a *App) PreviewAccounts(cookieText string) []AccountPreview {
|
||
previews := make([]AccountPreview, 0)
|
||
for _, line := range splitCookieLines(cookieText) {
|
||
uid := huya.ResolveUID(line.text)
|
||
item := AccountPreview{Line: line.lineNo, UID: uid, Valid: uid > 0}
|
||
if uid <= 0 {
|
||
item.Error = "无法解析 yyuid/udb_uid"
|
||
}
|
||
previews = append(previews, item)
|
||
}
|
||
return previews
|
||
}
|
||
|
||
func (a *App) IsRunning() bool {
|
||
a.runMu.Lock()
|
||
defer a.runMu.Unlock()
|
||
return a.monitorRunning
|
||
}
|
||
|
||
func (a *App) ListPrizes(cfg Config) (PrizeListResult, error) {
|
||
cfg = normalizeConfig(cfg)
|
||
accounts, err := parseAccounts(cfg)
|
||
if err != nil {
|
||
return PrizeListResult{}, err
|
||
}
|
||
if cfg.SID <= 0 {
|
||
return PrizeListResult{}, errors.New("SID 不能为空")
|
||
}
|
||
client, closeClient, err := a.newClient(cfg)
|
||
if err != nil {
|
||
return PrizeListResult{}, err
|
||
}
|
||
defer closeClient()
|
||
|
||
ctx, cancel := requestContext(cfg.TimeoutSec)
|
||
defer cancel()
|
||
resp, err := client.GetActPrizeList(ctx, accounts[0].UID, accounts[0].Cookie, cfg.SID)
|
||
if err != nil {
|
||
a.addLog("error", "查询奖品失败: %v", err)
|
||
return PrizeListResult{}, err
|
||
}
|
||
left, total, leftKnown, totalKnown := prizeInventorySummary(resp.Prizes)
|
||
a.addLog("info", "查询商品完成: uid=%d sid=%d status=%d count=%d 剩余=%d/%d项 总量=%d/%d项 类目=%s msg=%s", accounts[0].UID, cfg.SID, resp.Status, len(resp.Prizes), left, leftKnown, total, totalKnown, resp.CategorySummary(), resp.Msg)
|
||
return PrizeListResult{
|
||
UID: accounts[0].UID,
|
||
Status: resp.Status,
|
||
Msg: resp.Msg,
|
||
Prizes: resp.Prizes,
|
||
Categories: resp.Tags,
|
||
CategoryStats: resp.CategoryStats(),
|
||
Raw: resp,
|
||
}, nil
|
||
}
|
||
|
||
func (a *App) QueryScores(cfg Config) ([]ScoreResult, error) {
|
||
cfg = normalizeConfig(cfg)
|
||
accounts, err := parseAccounts(cfg)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if cfg.SID <= 0 {
|
||
return nil, errors.New("SID 不能为空")
|
||
}
|
||
client, closeClient, err := a.newClient(cfg)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer closeClient()
|
||
|
||
results := make([]ScoreResult, len(accounts))
|
||
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
|
||
ctx, cancel := requestContext(cfg.TimeoutSec)
|
||
defer cancel()
|
||
resp, err := client.QueryUserScore(ctx, account.UID, account.Cookie, cfg.SID)
|
||
item := ScoreResult{UID: account.UID, Resp: resp, Error: errorString(err)}
|
||
if resp != nil {
|
||
item.Score = resp.AvailableScore()
|
||
}
|
||
results[i] = item
|
||
})
|
||
a.addLog("info", "查询积分完成: accounts=%d", len(accounts))
|
||
return results, nil
|
||
}
|
||
|
||
func (a *App) GetRecords(cfg Config) ([]RecordResult, error) {
|
||
cfg = normalizeConfig(cfg)
|
||
accounts, err := parseAccounts(cfg)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if cfg.SID <= 0 {
|
||
return nil, errors.New("SID 不能为空")
|
||
}
|
||
client, closeClient, err := a.newClient(cfg)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer closeClient()
|
||
|
||
results := make([]RecordResult, len(accounts))
|
||
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
|
||
ctx, cancel := requestContext(cfg.TimeoutSec)
|
||
defer cancel()
|
||
resp, err := client.GetUserPrizeRecords(ctx, account.UID, account.Cookie, cfg.SID)
|
||
item := RecordResult{UID: account.UID, Resp: resp, Error: errorString(err)}
|
||
if resp != nil {
|
||
item.Records = resp.Records
|
||
}
|
||
results[i] = item
|
||
})
|
||
a.addLog("info", "查询兑换记录完成: accounts=%d", len(accounts))
|
||
return results, nil
|
||
}
|
||
|
||
func (a *App) Exchange(cfg Config) ([]ExchangeResult, error) {
|
||
cfg = normalizeConfig(cfg)
|
||
accounts, err := parseAccounts(cfg)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if cfg.SID <= 0 || cfg.PID <= 0 {
|
||
return nil, errors.New("SID 和 PID 都不能为空")
|
||
}
|
||
client, closeClient, err := a.newClient(cfg)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer closeClient()
|
||
|
||
results := make([]ExchangeResult, len(accounts))
|
||
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
|
||
ctx, cancel := requestContext(cfg.TimeoutSec)
|
||
defer cancel()
|
||
resp, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, cfg.SID, cfg.PID)
|
||
results[i] = ExchangeResult{
|
||
UID: account.UID,
|
||
Resp: resp,
|
||
Category: sniper.ClassifyExchange(resp, err),
|
||
Message: sniper.ExchangeMessage(resp),
|
||
Error: errorString(err),
|
||
}
|
||
})
|
||
a.addLog("info", "直接兑换完成: sid=%d pid=%d accounts=%d", cfg.SID, cfg.PID, len(accounts))
|
||
return results, nil
|
||
}
|
||
|
||
func (a *App) StartMonitor(cfg Config) error {
|
||
cfg = normalizeConfig(cfg)
|
||
accounts, err := parseAccounts(cfg)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if cfg.SID <= 0 {
|
||
return errors.New("SID 不能为空")
|
||
}
|
||
targets := parseTargets(cfg)
|
||
if len(targets) == 0 {
|
||
return errors.New("PID 和名称至少填写一个")
|
||
}
|
||
startAt, err := parseStartTime(cfg.StartAt)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
a.runMu.Lock()
|
||
if a.monitorRunning {
|
||
a.runMu.Unlock()
|
||
return errors.New("监控已在运行")
|
||
}
|
||
ctx, cancel := context.WithCancel(context.Background())
|
||
a.monitorCancel = cancel
|
||
a.monitorRunning = true
|
||
a.runMu.Unlock()
|
||
|
||
client, closeClient, err := a.newClient(cfg)
|
||
if err != nil {
|
||
cancel()
|
||
a.finishMonitor("启动失败")
|
||
return err
|
||
}
|
||
|
||
a.emitState(true, "运行中")
|
||
a.addLog("info", "启动监控: sid=%d 类目=%s targets=%d accounts=%d prewarm=%v direct=%v", cfg.SID, sniper.CategoryText(cfg.Category), len(targets), len(accounts), cfg.Prewarm, cfg.DirectExchange)
|
||
|
||
go func() {
|
||
defer closeClient()
|
||
defer a.finishMonitor("已停止")
|
||
|
||
runner := sniper.Runner{Client: client, OnSummary: a.logRunSummary}
|
||
emit := func(result sniper.Result) {
|
||
a.emit(eventMonitorResult, result)
|
||
a.logAccount(categoryMonitor, sniper.LogLevelForCategory(result.Category), strconv.FormatInt(result.UID, 10),
|
||
"loop=%d action=%s category=%s msg=%s error=%s", result.Loop, result.Action, result.Category, result.Message, result.Error)
|
||
}
|
||
runnerCfg := runnerConfig(cfg)
|
||
if cfg.Prewarm {
|
||
a.addLog("info", "开始预热连接: accounts=%d", len(accounts))
|
||
if err := runner.Prewarm(ctx, accounts, runnerCfg, emit); err != nil {
|
||
a.addLog("error", "连接预热异常: %v", err)
|
||
return
|
||
}
|
||
}
|
||
if !startAt.IsZero() {
|
||
when := startAt.Add(-time.Duration(cfg.LeadMS) * time.Millisecond)
|
||
a.addLog("info", "等待定时开始: %s 提前=%dms", when.Format("2006-01-02 15:04:05.000"), cfg.LeadMS)
|
||
if err := waitUntil(ctx, when); err != nil {
|
||
a.addLog("info", "定时等待已取消")
|
||
return
|
||
}
|
||
}
|
||
|
||
err := runner.RunTargets(ctx, accounts, targets, runnerCfg, emit)
|
||
if err != nil && !errors.Is(err, context.Canceled) {
|
||
a.addLog("error", "监控结束异常: %v", err)
|
||
}
|
||
}()
|
||
return nil
|
||
}
|
||
|
||
// runnerConfig 把界面配置翻译成抢购引擎配置。
|
||
//
|
||
// directExchange 是界面上的「直接兑换」开关：关掉时表示先查列表再兑换，
|
||
// 也就是 ListBeforeExchange=true，这样价格/库存过滤才会生效。
|
||
// 旧实现把 directExchange 单独透传，而引擎在 ListBeforeExchange=false 时会
|
||
// 强制回落到直兑（见 sniper.normalizeConfig），界面开关因此形同失效。
|
||
func runnerConfig(cfg Config) sniper.Config {
|
||
return sniper.Config{
|
||
SID: cfg.SID,
|
||
Category: cfg.Category,
|
||
Loops: cfg.Loops,
|
||
Delay: time.Duration(cfg.DelayMS) * time.Millisecond,
|
||
Concurrency: cfg.Concurrency,
|
||
StopAfterSuccess: cfg.StopAfterSuccess,
|
||
StopAccountAfterSuccess: cfg.StopAccountAfterSuccess,
|
||
Prewarm: false,
|
||
DirectExchange: cfg.DirectExchange,
|
||
ListBeforeExchange: !cfg.DirectExchange,
|
||
SharePrizeList: cfg.SharePrizeList,
|
||
RefreshAfterSuccess: cfg.RefreshAfterSuccess,
|
||
TooFrequentBackoff: time.Duration(cfg.FrequentBackoffMS) * time.Millisecond,
|
||
ErrorBackoff: time.Duration(cfg.ErrorBackoffMS) * time.Millisecond,
|
||
}
|
||
}
|
||
|
||
// logRunSummary 输出一行任务汇总，并按次数列出各类结局，便于在「监控」日志里复盘。
|
||
func (a *App) logRunSummary(summary sniper.RunSummary) {
|
||
a.addLog("info", "任务结束: 轮次=%d 账号=%d 目标=%d 成功账号=%d 耗时=%s 请求[列表=%d 兑换=%d 积分=%d 记录=%d]",
|
||
summary.Loops, summary.Accounts, summary.Targets, summary.SuccessUIDs,
|
||
summary.Duration.Round(time.Millisecond),
|
||
summary.ListReqs, summary.ExchangeReqs, summary.ScoreReqs, summary.RecordReqs)
|
||
for _, category := range summary.Categories() {
|
||
a.logEvent(categoryMonitor, sniper.LogLevelForCategory(category), "结局 %s ×%d", category, summary.Outcomes[category])
|
||
}
|
||
}
|
||
|
||
func (a *App) StopMonitor() bool {
|
||
a.runMu.Lock()
|
||
cancel := a.monitorCancel
|
||
a.runMu.Unlock()
|
||
if cancel == nil {
|
||
return false
|
||
}
|
||
cancel()
|
||
return true
|
||
}
|
||
|
||
// newClient 创建活动客户端，并把逐条网络交互接到 debug 级日志。
|
||
func (a *App) newClient(cfg Config) (huya.ActivityClient, func(), error) {
|
||
return huya.NewActivityClient(cfg.Transport, cfg.WSSHost, time.Duration(cfg.TimeoutSec)*time.Second, func(msg string) {
|
||
a.logEvent(categoryNet, logger.LevelDebug, "%s", msg)
|
||
})
|
||
}
|
||
|
||
func (a *App) runConcurrent(accounts []sniper.Account, concurrency int, fn func(i int, account sniper.Account)) {
|
||
if concurrency <= 0 {
|
||
concurrency = 1
|
||
}
|
||
sem := make(chan struct{}, concurrency)
|
||
var wg sync.WaitGroup
|
||
for i, account := range accounts {
|
||
i, account := i, account
|
||
wg.Add(1)
|
||
go func() {
|
||
defer wg.Done()
|
||
sem <- struct{}{}
|
||
defer func() { <-sem }()
|
||
fn(i, account)
|
||
}()
|
||
}
|
||
wg.Wait()
|
||
}
|
||
|
||
func (a *App) finishMonitor(message string) {
|
||
a.runMu.Lock()
|
||
a.monitorCancel = nil
|
||
a.monitorRunning = false
|
||
a.runMu.Unlock()
|
||
a.emitState(false, message)
|
||
}
|
||
|
||
// addLog 记录一条应用级日志。
|
||
func (a *App) addLog(level, format string, args ...any) {
|
||
logger.LogEvent(categoryApp, level, format, args...)
|
||
}
|
||
|
||
// logEvent 记录一条带分类的日志。
|
||
func (a *App) logEvent(category, level, format string, args ...any) {
|
||
logger.LogEvent(category, level, format, args...)
|
||
}
|
||
|
||
// logAccount 记录一条带账号标签的日志，便于界面按账号观察抢购链路。
|
||
func (a *App) logAccount(category, level, account string, format string, args ...any) {
|
||
logger.LogAccountEvent(category, level, account, format, args...)
|
||
}
|
||
|
||
func (a *App) emitState(running bool, message string) {
|
||
a.emit(eventMonitorState, MonitorState{Running: running, Message: message})
|
||
}
|
||
|
||
func (a *App) emit(event string, data any) {
|
||
if a.ctx == nil {
|
||
return
|
||
}
|
||
runtime.EventsEmit(a.ctx, event, data)
|
||
}
|
||
|
||
func normalizeConfig(cfg Config) Config {
|
||
if strings.TrimSpace(cfg.Transport) == "" {
|
||
cfg.Transport = "wss"
|
||
}
|
||
// WSSHost 留空表示走 launch.queryHttpDns 自动解析，不在这里补默认值。
|
||
if cfg.Loops <= 0 {
|
||
cfg.Loops = 1
|
||
}
|
||
if cfg.DelayMS <= 0 {
|
||
cfg.DelayMS = 150
|
||
}
|
||
if cfg.Concurrency <= 0 {
|
||
cfg.Concurrency = 1
|
||
}
|
||
if cfg.LeadMS < 0 {
|
||
cfg.LeadMS = 0
|
||
}
|
||
if cfg.FrequentBackoffMS <= 0 {
|
||
cfg.FrequentBackoffMS = 300
|
||
}
|
||
if cfg.ErrorBackoffMS <= 0 {
|
||
cfg.ErrorBackoffMS = 300
|
||
}
|
||
if cfg.TimeoutSec <= 0 {
|
||
cfg.TimeoutSec = 15
|
||
}
|
||
cfg.Name = strings.TrimSpace(cfg.Name)
|
||
cfg.Category = strings.TrimSpace(cfg.Category)
|
||
cfg.TargetText = strings.TrimSpace(cfg.TargetText)
|
||
cfg.CookieText = strings.TrimSpace(cfg.CookieText)
|
||
cfg.StartAt = strings.TrimSpace(cfg.StartAt)
|
||
return cfg
|
||
}
|
||
|
||
func parseTargets(cfg Config) []sniper.Target {
|
||
targets := make([]sniper.Target, 0)
|
||
if cfg.PID > 0 || strings.TrimSpace(cfg.Name) != "" {
|
||
targets = append(targets, sniper.Target{PID: cfg.PID, Name: strings.TrimSpace(cfg.Name)})
|
||
}
|
||
if cfg.AutoSelect {
|
||
targets = append(targets, sniper.Target{Auto: true})
|
||
}
|
||
for _, item := range splitTargetText(cfg.TargetText) {
|
||
if item == "auto" || item == "自动" || item == "自动选择" {
|
||
targets = append(targets, sniper.Target{Auto: true})
|
||
continue
|
||
}
|
||
if pid, err := strconv.ParseInt(item, 10, 32); err == nil && pid > 0 {
|
||
targets = append(targets, sniper.Target{PID: int32(pid)})
|
||
continue
|
||
}
|
||
targets = append(targets, sniper.Target{Name: item})
|
||
}
|
||
// 价格/库存过滤对所有目标统一生效，避免逐处重复赋值。
|
||
for i := range targets {
|
||
targets[i].MaxPrice = cfg.MaxPrice
|
||
targets[i].MinLeft = cfg.MinLeft
|
||
}
|
||
return targets
|
||
}
|
||
|
||
func splitTargetText(text string) []string {
|
||
replacer := strings.NewReplacer("，", ",", "\n", ",", "\t", ",")
|
||
parts := strings.Split(replacer.Replace(text), ",")
|
||
out := make([]string, 0, len(parts))
|
||
for _, part := range parts {
|
||
item := strings.TrimSpace(part)
|
||
if item != "" {
|
||
out = append(out, item)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func parseAccounts(cfg Config) ([]sniper.Account, error) {
|
||
lines := splitCookieLines(cfg.CookieText)
|
||
if len(lines) == 0 {
|
||
return nil, errors.New("Cookie 不能为空")
|
||
}
|
||
selected := selectedLineSet(cfg.SelectedAccountLines)
|
||
accounts := make([]sniper.Account, 0, len(lines))
|
||
for _, cookie := range lines {
|
||
if len(selected) > 0 && !selected[cookie.lineNo] {
|
||
continue
|
||
}
|
||
uid := huya.ResolveUID(cookie.text)
|
||
if uid <= 0 {
|
||
return nil, fmt.Errorf("第 %d 行 Cookie 无法解析 yyuid/udb_uid", cookie.lineNo)
|
||
}
|
||
accounts = append(accounts, sniper.Account{UID: uid, Cookie: cookie.text})
|
||
}
|
||
if len(accounts) == 0 {
|
||
return nil, errors.New("未选择有效账号")
|
||
}
|
||
return accounts, nil
|
||
}
|
||
|
||
func selectedLineSet(lines []int) map[int]bool {
|
||
out := make(map[int]bool, len(lines))
|
||
for _, line := range lines {
|
||
if line > 0 {
|
||
out[line] = true
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func splitCookieLines(cookieText string) []cookieLine {
|
||
lines := strings.Split(normalizeCookieText(cookieText), "\n")
|
||
out := make([]cookieLine, 0, len(lines))
|
||
for i, line := range lines {
|
||
item := strings.TrimSpace(line)
|
||
if item == "" || strings.HasPrefix(item, "#") {
|
||
continue
|
||
}
|
||
out = append(out, cookieLine{lineNo: i + 1, text: item})
|
||
}
|
||
return out
|
||
}
|
||
|
||
func normalizeCookieText(cookieText string) string {
|
||
normalized := strings.NewReplacer(
|
||
"\r\n", "\n",
|
||
"\r", "\n",
|
||
`\r\n`, "\n",
|
||
`\r`, "\n",
|
||
`\n`, "\n",
|
||
).Replace(cookieText)
|
||
if strings.Contains(normalized, "\n") ||
|
||
(!strings.Contains(normalized, "/r/n") && !strings.Contains(normalized, "/r")) {
|
||
return normalized
|
||
}
|
||
return strings.NewReplacer(
|
||
"/r/n", "\n",
|
||
"/r", "\n",
|
||
"/n", "\n",
|
||
).Replace(normalized)
|
||
}
|
||
|
||
func requestContext(timeoutSec int) (context.Context, context.CancelFunc) {
|
||
if timeoutSec <= 0 {
|
||
timeoutSec = 15
|
||
}
|
||
return context.WithTimeout(context.Background(), time.Duration(timeoutSec)*time.Second)
|
||
}
|
||
|
||
func parseStartTime(text string) (time.Time, error) {
|
||
text = strings.TrimSpace(text)
|
||
if text == "" {
|
||
return time.Time{}, nil
|
||
}
|
||
if ts, err := strconv.ParseInt(text, 10, 64); err == nil {
|
||
return time.Unix(ts, 0), nil
|
||
}
|
||
for _, layout := range []string{"15:04:05", "15:04"} {
|
||
if t, err := time.ParseInLocation(layout, text, time.Local); err == nil {
|
||
return nextClockTime(time.Now(), t.Hour(), t.Minute(), t.Second()), nil
|
||
}
|
||
}
|
||
for _, layout := range []string{time.RFC3339, "2006-01-02 15:04:05", "2006-01-02 15:04"} {
|
||
if t, err := time.ParseInLocation(layout, text, time.Local); err == nil {
|
||
return t, nil
|
||
}
|
||
}
|
||
return time.Time{}, fmt.Errorf("无法解析开始时间: %s", text)
|
||
}
|
||
|
||
func nextClockTime(now time.Time, hour, minute, second int) time.Time {
|
||
target := time.Date(now.Year(), now.Month(), now.Day(), hour, minute, second, 0, now.Location())
|
||
if !target.After(now) {
|
||
target = target.Add(24 * time.Hour)
|
||
}
|
||
return target
|
||
}
|
||
|
||
// waitUntil 等到指定时刻。用一次性定时器精确睡眠，避免旧实现 200ms 轮询带来的
|
||
// 0-200ms 随机延迟（抢购时这段时间正好是关键窗口）。
|
||
func waitUntil(ctx context.Context, when time.Time) error {
|
||
for {
|
||
remaining := time.Until(when)
|
||
if remaining <= 0 {
|
||
return nil
|
||
}
|
||
timer := time.NewTimer(remaining)
|
||
select {
|
||
case <-timer.C:
|
||
case <-ctx.Done():
|
||
timer.Stop()
|
||
return ctx.Err()
|
||
}
|
||
}
|
||
}
|
||
|
||
func errorString(err error) string {
|
||
if err == nil {
|
||
return ""
|
||
}
|
||
return err.Error()
|
||
}
|
||
|
||
func prizeInventorySummary(prizes []huya.PrizeInfo) (left, total int64, leftKnown, totalKnown int) {
|
||
for _, prize := range prizes {
|
||
if prize.Num > 0 {
|
||
total += prize.Num
|
||
totalKnown++
|
||
}
|
||
if itemLeft, ok := prize.InventoryLeft(); ok {
|
||
left += itemLeft
|
||
leftKnown++
|
||
}
|
||
}
|
||
return left, total, leftKnown, totalKnown
|
||
}
|