美团抢单脚本辅助工具，自动抢单辅助精灵插件，美团自动抢单辅助软件下载

/**
 * Auto.js抢单系统
 * 功能：实时监控订单列表，根据价格/距离/预定条件自动抢单
 * 作者：百度AI
 * 日期：2025-06-24
 */

// ================ 全局配置 ================
const CONFIG = {
  MIN_PRICE: 30,       // 最低接单价格
  MAX_DISTANCE: 5,     // 最远接单距离(km)
  ACCEPT_PREORDER: true, // 是否接受预定单
  SCAN_INTERVAL: 800,  // 扫描间隔(ms)
  DEBUG_MODE: true     // 调试模式
};

// ================ 工具函数模块 ================
function logDebug(msg) {
  if (CONFIG.DEBUG_MODE) console.log("[DEBUG] " + msg);
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

function calculateDistance(lat1, lon1, lat2, lon2) {
  // 简化版距离计算（Haversine公式）
  const R = 6371; // 地球半径(km)
  const dLat = (lat2 - lat1) * Math.PI / 180;
  const dLon = (lon2 - lon1) * Math.PI / 180;
  const a = 
    Math.sin(dLat/2) * Math.sin(dLat/2) +
    Math.cos(lat1 * Math.PI / 180) * 
    Math.cos(lat2 * Math.PI / 180) * 
    Math.sin(dLon/2) * Math.sin(dLon/2);
  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
}

// ================ 界面元素定位模块 ================
const UI_ELEMENTS = {
  // 订单列表相关
  ORDER_LIST: () => id("order_list_container").findOne(),
  ORDER_ITEMS: () => className("android.widget.LinearLayout")
    .depth(10)
    .inside(UI_ELEMENTS.ORDER_LIST()),
  
  // 单个订单元素
  ORDER_PRICE: (item) => item.findOne(id("order_price")),
  ORDER_DISTANCE: (item) => item.findOne(id("order_distance")),
  ORDER_ADDRESS: (item) => item.findOne(id("order_address")),
  ORDER_PREORDER: (item) => item.findOne(id("order_preorder_flag")),
  ORDER_ACCEPT_BTN: (item) => item.findOne(id("accept_button")),
  
  // 系统弹窗
  CONFIRM_DIALOG: () => textMatches(/确认接单|确定/).findOne(2000),
  SYSTEM_ALERT: () => textMatches(/警告|提示|错误/).findOne(1000)
};

// ================ 订单处理模块 ================
class OrderProcessor {
  constructor() {
    this.currentLocation = { lat: 39.9042, lng: 116.4074 }; // 默认北京坐标
    this.lastOrderTime = 0;
  }
  
  async processOrderList() {
    const orders = UI_ELEMENTS.ORDER_ITEMS();
    if (!orders || orders.length === 0) {
      logDebug("未检测到订单列表");
      return false;
    }
    
    logDebug("发现 " + orders.length + " 个待处理订单");
    for (let i = 0; i < orders.length; i++) {
      if (await this.checkAndAcceptOrder(orders[i])) {
        return true; // 成功接单后暂停处理
      }
    }
    return false;
  }
  
  async checkAndAcceptOrder(orderItem) {
    try {
      // 提取订单信息
      const priceText = UI_ELEMENTS.ORDER_PRICE(orderItem).text();
      const price = parseFloat(priceText.replace(/[^\d.]/g, ''));
      
      const distanceText = UI_ELEMENTS.ORDER_DISTANCE(orderItem).text();
      const distance = parseFloat(distanceText.match(/\d+\.?\d*/)[0]);
      
      const isPreorder = UI_ELEMENTS.ORDER_PREORDER(orderItem).exists();
      const address = UI_ELEMENTS.ORDER_ADDRESS(orderItem).text();
      
      logDebug(`订单检查: 价格${price} 距离${distance}km 预定${isPreorder} 地址${address}`);
      
      // 验证接单条件
      if (price < CONFIG.MIN_PRICE) {
        logDebug("价格不符合要求");
        return false;
      }
      
      if (distance > CONFIG.MAX_DISTANCE) {
        logDebug("距离超出限制");
        return false;
      }
      
      if (isPreorder && !CONFIG.ACCEPT_PREORDER) {
        logDebug("不接受预定单");
        return false;
      }
      
      // 执行接单操作
      logDebug("符合接单条件，尝试接单...");
      UI_ELEMENTS.ORDER_ACCEPT_BTN(orderItem).click();
      await sleep(500);
      
      // 处理确认弹窗
      if (UI_ELEMENTS.CONFIRM_DIALOG()) {
        UI_ELEMENTS.CONFIRM_DIALOG().click();
        logDebug("已确认接单");
        this.lastOrderTime = Date.now();
        return true;
      }
      
      // 处理系统警告
      if (UI_ELEMENTS.SYSTEM_ALERT()) {
        logDebug("接单失败: " + UI_ELEMENTS.SYSTEM_ALERT().text());
        UI_ELEMENTS.SYSTEM_ALERT().parent().child(0).click(); // 关闭弹窗
        return false;
      }
      
    } catch (e) {
      logDebug("订单处理异常: " + e);
    }
    return false;
  }
}

// ================ 主循环模块 ================
async function mainLoop() {
  const processor = new OrderProcessor();
  logDebug("抢单系统启动，配置参数: " + JSON.stringify(CONFIG));
  
  while (true) {
    try {
      const success = await processor.processOrderList();
      if (success) {
        logDebug("接单成功，暂停处理10秒");
        await sleep(10000); // 接单成功后暂停
      }
    } catch (e) {
      logDebug("主循环异常: " + e);
    }
    await sleep(CONFIG.SCAN_INTERVAL);
  }
}

// ================ 异常处理模块 ================
function setupExceptionHandler() {
  events.on("exit", () => {
    console.log("抢单系统已停止");
  });
  
  events.observeKey();
  events.onKeyDown("volume_down", () => {
    console.log("手动停止脚本");
    exit();
  });
}

// ================ 启动入口 ================
function main() {
  // 检查运行环境
  if (!auto.service) {
    toast("请先开启无障碍服务");
    return;
  }
  
  setupExceptionHandler();
  threads.start(mainLoop);
  
  toast("抢单系统运行中\n按音量下键停止");
  console.show(); // 显示控制台
}

main();

/**
 * Auto.js多线程抢单系统
 * 包含：1.主控线程 2.订单处理线程 3.监控线程 4.日志线程
 * 开发日期：2025-06-24
 */

// ================ 全局配置 ================
const SHARED_DATA = {
  config: {
    minPrice: 30,
    maxDistance: 5,
    acceptPreorder: true,
    scanInterval: 800,
    maxThreads: 3
  },
  status: {
    running: true,
    ordersProcessed: 0,
    lastSuccessTime: 0
  },
  threads: {
    main: null,
    monitor: null,
    logger: null,
    workers: []
  }
};

// ================ 工具类模块 ================
class Utils {
  static distanceCalc(lat1, lon1, lat2, lon2) {
    const R = 6371;
    const dLat = this.toRad(lat2-lat1);
    const dLon = this.toRad(lon2-lon1);
    const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
      Math.cos(this.toRad(lat1)) * 
      Math.cos(this.toRad(lat2)) *
      Math.sin(dLon/2) * Math.sin(dLon/2);
    return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
  }

  static toRad(degrees) {
    return degrees * Math.PI / 180;
  }

  static formatTime(ms) {
    const date = new Date(ms);
    return date.toLocaleTimeString();
  }
}

// ================ 日志线程 ================
function startLoggerThread() {
  threads.start(function(){
    const LOG_QUEUE = [];
    const MAX_LOG_SIZE = 1000;
    
    events.on("log", function(message) {
      LOG_QUEUE.push(Utils.formatTime(Date.now()) + " " + message);
      if(LOG_QUEUE.length > MAX_LOG_SIZE) {
        LOG_QUEUE.shift();
      }
    });

    while(SHARED_DATA.status.running) {
      if(LOG_QUEUE.length > 0) {
        console.log(LOG_QUEUE.join("\n"));
        LOG_QUEUE.length = 0;
      }
      sleep(3000);
    }
    events.emit("log", "日志线程已停止");
  });
}

// ================ 订单处理线程 ================
class OrderWorker {
  constructor(workerId) {
    this.id = workerId;
    this.currentTask = null;
  }

  run() {
    threads.start(() => {
      events.emit("log", `工作线程${this.id} 已启动`);
      
      while(SHARED_DATA.status.running) {
        try {
          if(this.currentTask) {
            this.processOrder(this.currentTask);
            this.currentTask = null;
          }
          sleep(100);
        } catch(e) {
          events.emit("log", `工作线程${this.id} 异常: ${e}`);
        }
      }
      events.emit("log", `工作线程${this.id} 已停止`);
    });
  }

  processOrder(orderData) {
    const startTime = Date.now();
    events.emit("log", `线程${this.id} 开始处理订单: ${orderData.id}`);
    
    // 模拟处理过程
    const processingTime = random(300, 1500);
    sleep(processingTime);
    
    if(Math.random() > 0.3) { // 70%成功率
      SHARED_DATA.status.ordersProcessed++;
      SHARED_DATA.status.lastSuccessTime = Date.now();
      events.emit("log", `线程${this.id} 成功接单 ${orderData.id} 耗时${processingTime}ms`);
      return true;
    }
    events.emit("log", `线程${this.id} 接单失败 ${orderData.id}`);
    return false;
  }
}

// ================ 监控线程 ================
function startMonitorThread() {
  threads.start(function(){
    events.emit("log", "监控线程已启动");
    let lastCheck = Date.now();
    
    while(SHARED_DATA.status.running) {
      try {
        // 线程健康检查
        const now = Date.now();
        if(now - lastCheck > 5000) {
          events.emit("log", `系统状态: 已处理 ${SHARED_DATA.status.ordersProcessed} 单`);
          lastCheck = now;
        }
        
        // 内存监控
        if(device.sdkInt >= 21) {
          const memInfo = context.getSystemService(context.ACTIVITY_SERVICE)
            .getMemoryInfo();
          if(memInfo.lowMemory) {
            events.emit("log", "警告: 系统内存不足");
          }
        }
        
        sleep(2000);
      } catch(e) {
        events.emit("log", "监控线程异常: " + e);
      }
    }
    events.emit("log", "监控线程已停止");
  });
}

// ================ 主控线程 ================
function main() {
  // 初始化线程池
  for(let i=0; i<SHARED_DATA.config.maxThreads; i++) {
    const worker = new OrderWorker(i+1);
    worker.run();
    SHARED_DATA.threads.workers.push(worker);
  }

  // 启动辅助线程
  startLoggerThread();
  startMonitorThread();
  events.emit("log", "主线程已启动");

  // 模拟订单生成
  let orderId = 1;
  while(SHARED_DATA.status.running) {
    try {
      // 生成模拟订单
      const newOrder = {
        id: "ORD" + (orderId++).toString().padStart(6, '0'),
        price: random(20, 100),
        distance: random(1, 10),
        timestamp: Date.now()
      };

      // 分配任务给空闲线程
      const freeWorker = SHARED_DATA.threads.workers.find(w => !w.currentTask);
      if(freeWorker) {
        freeWorker.currentTask = newOrder;
      }

      sleep(SHARED_DATA.config.scanInterval);
    } catch(e) {
      events.emit("log", "主线程异常: " + e);
    }
  }
  events.emit("log", "主线程已停止");
}

// ================ 启动与停止控制 ================
function setupControl() {
  events.observeKey();
  events.onKeyDown("volume_up", function(){
    SHARED_DATA.status.running = false;
    console.show();
    sleep(3000);
    exit();
  });
  
  device.keepScreenOn();
  console.setTitle("多线程抢单系统");
  console.setSize(800, 600);
}

// ================ 程序入口 ================
setupControl();
main();