Python脚本控制鼠标键盘

  

   

    

     

    
    

     

      import time
     
    
   

    

     

    
    

     

      import pyautogui 
      as pg
     
    
   

    

     

    
    

     

      from PIL 
      import Image
     
    
   

    

     

    
    

     

      import random
     
    
   

    

     

    
    

     

      import datetime
     
    
   

    

     

    
    

     

      import threading
     
    
   

    

     

    
    

     

      import os
     
    
   

    

     

    
    

     

      import keyboard 
      as kb
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      AutoPalyFlag = 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 设置 图标 box
     
    
   

    

     

    
    

     

      box_settings = (
      1890, 
      870, 
      1920, 
      900)
     
    
   

    

     

    
    

     

      # 发起投降 按钮 box
     
    
   

    

     

    
    

     

      box_surrender = (
      700, 
      820, 
      840, 
      860)
     
    
   

    

     

    
    

     

      # 确认投降 按钮 box
     
    
   

    

     

    
    

     

      box_confirm = (
      720, 
      460, 
      940, 
      520)
     
    
   

    

     

    
    

     

      # 空白区域
     
    
   

    

     

    
    

     

      box_empty_area = (
      700, 
      0, 
      800, 
      10)
     
    
   

    

     

    
    

     

      # 再玩一次
     
    
   

    

     

    
    

     

      box_play_again = (
      530, 
      830, 
      780, 
      880)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 商店5个怪的box
     
    
   

    

     

    
    

     

      champ_box = [
     
    
   

    

     

    
    

     

          (
      480, 
      930, 
      670, 
      1070),
     
    
   

    

     

    
    

     

          (
      680, 
      930, 
      870, 
      1070),
     
    
   

    

     

    
    

     

          (
      880, 
      930, 
      1070, 
      1070),
     
    
   

    

     

    
    

     

          (
      1080, 
      930, 
      1270, 
      1070),
     
    
   

    

     

    
    

     

          (
      1290, 
      930, 
      1480, 
      1070),
     
    
   

    

     

    
    

     

      ]
     
    
   

    

     

    
    

     

      pg.FAILSAFE = 
      False
     
    
   

    

     

    
    

     

      log_path = 
      'log\\%s.log'%time.strftime(
      '%Y_%m_%d_%H_%M_%S')
     
    
   

    

     

    
    

     

      log_file = open(log_path, 
      'w', encoding=
      'utf8')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def slow_click(p, button='PRIMARY', move_time = 0.2, down_time = 0.2, up_time = 0.2):
     
    
   

    

     

    
    

     

          pg.moveTo(p[
      0], p[
      1], duration=move_time)
     
    
   

    

     

    
    

     

          pg.mouseDown(p[
      0], p[
      1], button=button, duration = down_time)
     
    
   

    

     

    
    

     

          pg.mouseUp(p[
      0], p[
      1], button=button, duration = up_time)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def slow_key_press(key, down_time = 0.2):
     
    
   

    

     

    
    

     

          kb.press(key)
     
    
   

    

     

    
    

     

          time.sleep(down_time)
     
    
   

    

     

    
    

     

          kb.release(key)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def record_and_print_log(log):
     
    
   

    

     

    
    

     
    
      global log_file
     
    
   

    

     

    
    

     

          print(log)
     
    
   

    

     

    
    

     

          log_file.write(log)
     
    
   

    

     

    
    

     

          log_file.write(
      '\n')
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def get_time_fmt_str(t = None):
     
    
   

    

     

    
    

     
    
      if 
      not t:
     
    
   

    

     

    
    

     

              t = time.localtime()
     
    
   

    

     

    
    

     
    
      return time.strftime(
      "%Y/%m/%d %H:%M:%S", t)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def stray():
     
    
   

    

     

    
    

     
    
      # 在棋盘小范围内随机游荡，防止鼠标指针挡住关卡图片导致检测不到3-2关卡
     
    
   

    

     

    
    

     

          x = random.randint(
      500, 
      1200)
     
    
   

    

     

    
    

     

          y = random.randint(
      250, 
      650)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          slow_click((x,y), button=
      'right', move_time=
      0.5)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 买一个怪
     
    
   

    

     

    
    

     

      def buy_single_champ(index):
     
    
   

    

     

    
    

     
    
      global champ_box
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      if index > 
      4:
     
    
   

    

     

    
    

     

              index = 
      4
     
    
   

    

     

    
    

     
    
      if index < 
      0:
     
    
   

    

     

    
    

     

              index = 
      0
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          box = champ_box[index]
     
    
   

    

     

    
    

     

          center = get_box_center(box)
     
    
   

    

     

    
    

     

          slow_click(center, move_time=
      0.3)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 刷新商店
     
    
   

    

     

    
    

     

      def refresh_shop():
     
    
   

    

     

    
    

     

          kb.press_and_release(
      'd')
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def show_emoji():
     
    
   

    

     

    
    

     

          kb.press_and_release(
      't')
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 提升等级
     
    
   

    

     

    
    

     

      def upgrade_champ():
     
    
   

    

     

    
    

     

          kb.press_and_release(
      'f')
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def get_lol_hwnd():
     
    
   

    

     

    
    

     

          title = 
      'League of Legends'
     
    
   

    

     

    
    

     

          w = pg.getWindowsWithTitle(title)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          hwnd = 
      False
     
    
   

    

     

    
    

     
    
      for i 
      in w:
     
    
   

    

     

    
    

     
        
      if i.title == title:
     
    
   

    

     

    
    

     

                  hwnd = i
     
    
   

    

     

    
    

     
            
      break
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return hwnd
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def get_box_center(box):
     
    
   

    

     

    
    

     

          x = int((box[
      2] - box[
      0]) / 
      2) + box[
      0]
     
    
   

    

     

    
    

     

          y = int((box[
      3] - box[
      1]) / 
      2) + box[
      1]
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return (x, y)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def move_to_empty_area(lol_hwnd):
     
    
   

    

     

    
    

     
    
      global  box_empty_area
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 客户端已经最小化，不移动鼠标
     
    
   

    

     

    
    

     
    
      if lol_hwnd.size < (
      1024, 
      768):
     
    
   

    

     

    
    

     
        
      return
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          center = convert_lol_to_destop_point(get_box_center(box_empty_area), lol_hwnd)
     
    
   

    

     

    
    

     

          pg.moveTo(center[
      0], center[
      1], duration = 
      0.1)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 将LOL客户端相对坐标根据LOL客户端位置转换为实际桌面的绝对坐标
     
    
   

    

     

    
    

     

      def convert_lol_to_destop_point(p, lol_hwnd):
     
    
   

    

     

    
    

     

          x = lol_hwnd.topleft[
      0] + p[
      0]
     
    
   

    

     

    
    

     

          y = lol_hwnd.topleft[
      1] + p[
      1]
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return (x, y)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def surrender():
     
    
   

    

     

    
    

     
    
      global box_settings, box_surrender, box_confirm
     
    
   

    

     

    
    

     
    
      # center = get_box_center(box_settings)
     
    
   

    

     

    
    

     
    
      # 点击设置
     
    
   

    

     

    
    

     
    
      # slow_click(center, move_time=0.5)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          slow_key_press(
      'esc')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          center = get_box_center(box_surrender)
     
    
   

    

     

    
    

     
    
      # 发起投降
     
    
   

    

     

    
    

     

          slow_click(center, move_time=
      0.5)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          center = get_box_center(box_confirm)
     
    
   

    

     

    
    

     
    
      # 确定离开
     
    
   

    

     

    
    

     

          slow_click(center, move_time=
      0.5)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 卖掉候选台前三个怪，和棋盘上自动上的怪
     
    
   

    

     

    
    

     

      def sell_monsters():
     
    
   

    

     

    
    

     

          slot1 = (
      443, 
      758)
     
    
   

    

     

    
    

     

          slot2 = (
      576, 
      758)
     
    
   

    

     

    
    

     

          slot3 = (
      696, 
      758)
     
    
   

    

     

    
    

     

          slot4 = (
      975, 
      672)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          pg.moveTo(slot1)
     
    
   

    

     

    
    

     

          slow_key_press(
      'e')
     
    
   

    

     

    
    

     

          time.sleep(
      1)
     
    
   

    

     

    
    

     

          pg.moveTo(slot2)
     
    
   

    

     

    
    

     

          slow_key_press(
      'e')
     
    
   

    

     

    
    

     

          time.sleep(
      1)
     
    
   

    

     

    
    

     

          pg.moveTo(slot3)
     
    
   

    

     

    
    

     

          slow_key_press(
      'e')
     
    
   

    

     

    
    

     

          time.sleep(
      1)
     
    
   

    

     

    
    

     

          pg.moveTo(slot4)
     
    
   

    

     

    
    

     

          slow_key_press(
      'e')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      game_inactive_count = 
      0
     
    
   

    

     

    
    

     

      # 切换到游戏
     
    
   

    

     

    
    

     

      def make_game_active(game_hwnd):
     
    
   

    

     

    
    

     
    
      global game_inactive_count
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      while 
      not game_hwnd.isActive:
     
    
   

    

     

    
    

     

              game_hwnd.activate()
     
    
   

    

     

    
    

     

              pg.press(
      'enter')
     
    
   

    

     

    
    

     

              time.sleep(
      2)
     
    
   

    

     

    
    

     

          game_inactive_count = 
      0
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 让游戏处于活动状态
     
    
   

    

     

    
    

     

      def check_game_active(game_hwnd):
     
    
   

    

     

    
    

     
    
      global game_inactive_count
     
    
   

    

     

    
    

     
    
      if 
      not game_hwnd.isActive:
     
    
   

    

     

    
    

     

              game_inactive_count += 
      1
     
    
   

    

     

    
    

     
    
      else :
     
    
   

    

     

    
    

     

              game_inactive_count = 
      0
     
    
   

    

     

    
    

     
    
      # 等待3 * 5秒，游戏还未切换回来，就主动切换回来
     
    
   

    

     

    
    

     
    
      if game_inactive_count > 
      3:
     
    
   

    

     

    
    

     

              make_game_active(game_hwnd)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 开始匹配
     
    
   

    

     

    
    

     

      def click_find_match(lol_hwnd):
     
    
   

    

     

    
    

     

          pic_find_match = Image.open(
      r'scs\find_match.jpg')
     
    
   

    

     

    
    

     

          p = pg.locateCenterOnScreen(pic_find_match, confidence=
      0.9)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      if p:
     
    
   

    

     

    
    

     

              slow_click(p)
     
    
   

    

     

    
    

     

              move_to_empty_area(lol_hwnd)
     
    
   

    

     

    
    

     
    
      else:
     
    
   

    

     

    
    

     
        
      return 
      False
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      if 
      not pg.locateCenterOnScreen(pic_find_match, confidence=
      0.9):
     
    
   

    

     

    
    

     
        
      return 
      True
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      return 
      False
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 等待太久，重新匹配
     
    
   

    

     

    
    

     

      def stop_and_start_a_new_match(lol_hwnd):
     
    
   

    

     

    
    

     

          pic = Image.open(
      r'scs\stop.png')
     
    
   

    

     

    
    

     

          p = pg.locateCenterOnScreen(pic, confidence=
      0.9)
     
    
   

    

     

    
    

     
    
      if p:
     
    
   

    

     

    
    

     

              slow_click(p)
     
    
   

    

     

    
    

     

              move_to_empty_area(lol_hwnd)
     
    
   

    

     

    
    

     
    
      else:
     
    
   

    

     

    
    

     

              record_and_print_log(
      '找不到停止按钮！')
     
    
   

    

     

    
    

     
        
      return 
      False
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          time.sleep(
      1)
     
    
   

    

     

    
    

     
    
      return  click_find_match(lol_hwnd)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 等待并接受对局
     
    
   

    

     

    
    

     

      def accept_match(lol_hwnd):
     
    
   

    

     

    
    

     
    
      # 5分钟未进入游戏，直接重新匹配
     
    
   

    

     

    
    

     

          timeout = 
      5 * 
      60
     
    
   

    

     

    
    

     

          start_time = time.time()
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          pic_accept = Image.open(
      r'scs\accept.jpg')
     
    
   

    

     

    
    

     
    
      while time.time() - start_time < timeout * 
      10:
     
    
   

    

     

    
    

     
        
      while time.time() - start_time < timeout:
     
    
   

    

     

    
    

     

                  p = pg.locateCenterOnScreen(pic_accept, confidence = 
      0.93)
     
    
   

    

     

    
    

     
            
      if p:
     
    
   

    

     

    
    

     

                      slow_click(p)
     
    
   

    

     

    
    

     

                      move_to_empty_area(lol_hwnd)
     
    
   

    

     

    
    

     
            
      # 客户端已最小化，正在启动游戏
     
    
   

    

     

    
    

     
            
      if lol_hwnd.size < (
      1024, 
      768):
     
    
   

    

     

    
    

     
                
      return 
      True
     
    
   

    

     

    
    

     

                  time.sleep(
      1)
     
    
   

    

     

    
    

     
        
      # 等待太久，重新匹配
     
    
   

    

     

    
    

     
        
      if 
      not stop_and_start_a_new_match(lol_hwnd):
     
    
   

    

     

    
    

     
            
      return 
      False
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          record_and_print_log(
      "10次超时未找到对局！")
     
    
   

    

     

    
    

     
    
      return 
      False
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 寻找对局 -> 队列中 -> 接受 -> 开始加载
     
    
   

    

     

    
    

     

      # 寻找对局 -> 队列中 -> 接受 -> 有人拒绝 -> 队列中
     
    
   

    

     

    
    

     

      def pg_find_match(lol_hwnd):
     
    
   

    

     

    
    

     

          click_find_match(lol_hwnd)
     
    
   

    

     

    
    

     
    
      return accept_match(lol_hwnd)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def pg_wait_loading(lol_hwnd):
     
    
   

    

     

    
    

     

          pic = Image.open(
      r'scs\1_1.jpg')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      while 
      True:
     
    
   

    

     

    
    

     
        
      # pyautogui 模块检测关卡
     
    
   

    

     

    
    

     

              box = pg.locateOnScreen(pic, confidence=
      0.9)
     
    
   

    

     

    
    

     
        
      if box:
     
    
   

    

     

    
    

     
            
      return 
      True
     
    
   

    

     

    
    

     

              time.sleep(
      2)
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      WaitStageFlag = 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def change_wait_flag_callback():
     
    
   

    

     

    
    

     
    
      global WaitStageFlag
     
    
   

    

     

    
    

     

          record_and_print_log(
      "17分钟未检测到3-2回合，直接进行下一步操作")
     
    
   

    

     

    
    

     

          WaitStageFlag = 
      False
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 空城速八
     
    
   

    

     

    
    

     

      def pg_quick_wait_quit():
     
    
   

    

     

    
    

     
    
      global game_inactive_count
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "Start wait quit button")
     
    
   

    

     

    
    

     

          pic = Image.open(
      r'scs\quit.png')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          client_title = 
      'League of Legends (TM) Client'
     
    
   

    

     

    
    

     

          game_hwnd = pg.getWindowsWithTitle(client_title)[
      0]
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      while 
      True:
     
    
   

    

     

    
    

     
        
      # 让游戏处于活动状态
     
    
   

    

     

    
    

     

              check_game_active(game_hwnd)
     
    
   

    

     

    
    

     
        
      # 游戏被切换出去了，此时不操作鼠标键盘
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              box = pg.locateOnScreen(pic, confidence=
      0.95)
     
    
   

    

     

    
    

     
        
      if box:
     
    
   

    

     

    
    

     

                  slow_click(pg.center(box))
     
    
   

    

     

    
    

     
            
      break
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %50 概率游荡
     
    
   

    

     

    
    

     
        
      if case <= 
      50:
     
    
   

    

     

    
    

     

                  stray()
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %50 概率发表情
     
    
   

    

     

    
    

     
        
      if case <= 
      50:
     
    
   

    

     

    
    

     

                  show_emoji()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      # case = random.randint(1,100)
     
    
   

    

     

    
    

     
        
      # # %5 概率升级
     
    
   

    

     

    
    

     
        
      # if case >= 85 and case < 90:
     
    
   

    

     

    
    

     
        
      # upgrade_champ()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              sell_monsters()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 乱拿等死
     
    
   

    

     

    
    

     

      def pg_slow_wait_quit():
     
    
   

    

     

    
    

     
    
      global game_inactive_count
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "Start wait quit button")
     
    
   

    

     

    
    

     

          pic = Image.open(
      r'scs\quit.png')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          client_title = 
      'League of Legends (TM) Client'
     
    
   

    

     

    
    

     

          game_hwnd = pg.getWindowsWithTitle(client_title)[
      0]
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      while 
      True:
     
    
   

    

     

    
    

     
        
      # 让游戏处于活动状态
     
    
   

    

     

    
    

     

              check_game_active(game_hwnd)
     
    
   

    

     

    
    

     
        
      # 游戏被切换出去了，此时不操作鼠标键盘
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              box = pg.locateOnScreen(pic, confidence=
      0.95)
     
    
   

    

     

    
    

     
        
      if box:
     
    
   

    

     

    
    

     

                  slow_click(pg.center(box))
     
    
   

    

     

    
    

     
            
      break
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %40 概率游荡
     
    
   

    

     

    
    

     
        
      if case <= 
      40:
     
    
   

    

     

    
    

     

                  stray()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %25 概率买1个英雄
     
    
   

    

     

    
    

     
        
      if case >= 
      25 
      and case < 
      50:
     
    
   

    

     

    
    

     

                  buy_single_champ(random.randint(
      0, 
      4))
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      # case = random.randint(1,100)
     
    
   

    

     

    
    

     
        
      # %0 概率刷新商店
     
    
   

    

     

    
    

     
        
      # if case == 0:
     
    
   

    

     

    
    

     
            
      # refresh_shop()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %30 概率发表情
     
    
   

    

     

    
    

     
        
      if case <= 
      30:
     
    
   

    

     

    
    

     

                  show_emoji()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %5 概率升级
     
    
   

    

     

    
    

     
        
      if case >= 
      85 
      and case < 
      90:
     
    
   

    

     

    
    

     

                  upgrade_champ()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              time.sleep(
      1)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 速度投降
     
    
   

    

     

    
    

     

      def pg_wait_stage_3_2():
     
    
   

    

     

    
    

     
    
      global WaitStageFlag, game_inactive_count
     
    
   

    

     

    
    

     

          pic = Image.open(
      r'scs\3_2.jpg')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          WaitStageFlag = 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 启动一个Timer，17分钟未检测到3-2回合，直接进行下一步
     
    
   

    

     

    
    

     

          t = threading.Timer(
      17 * 
      60, change_wait_flag_callback)
     
    
   

    

     

    
    

     

          t.start()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          client_title = 
      'League of Legends (TM) Client'
     
    
   

    

     

    
    

     

          game_hwnd = pg.getWindowsWithTitle(client_title)[
      0]
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      while WaitStageFlag:
     
    
   

    

     

    
    

     
        
      # 让游戏处于活动状态
     
    
   

    

     

    
    

     

              check_game_active(game_hwnd)
     
    
   

    

     

    
    

     
        
      # 游戏被切换出去了，此时不操作鼠标键盘
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     
        
      # pyautogui 模块检测关卡
     
    
   

    

     

    
    

     

              box = pg.locateOnScreen(pic, confidence=
      0.9)
     
    
   

    

     

    
    

     
        
      if box:
     
    
   

    

     

    
    

     
            
      # 检测到3-2，停止Timer
     
    
   

    

     

    
    

     

                  t.cancel()
     
    
   

    

     

    
    

     
            
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %40 概率游荡
     
    
   

    

     

    
    

     
        
      if case <= 
      40:
     
    
   

    

     

    
    

     

                  stray()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %25 概率买1个英雄
     
    
   

    

     

    
    

     
        
      if case >= 
      25 
      and case < 
      50:
     
    
   

    

     

    
    

     

                  buy_single_champ(random.randint(
      0, 
      4))
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      # case = random.randint(1,100)
     
    
   

    

     

    
    

     
        
      # %0 概率刷新商店
     
    
   

    

     

    
    

     
        
      # if case == 0:
     
    
   

    

     

    
    

     
            
      # refresh_shop()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %30 概率发表情
     
    
   

    

     

    
    

     
        
      if case <= 
      30:
     
    
   

    

     

    
    

     

                  show_emoji()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      if game_inactive_count > 
      0:
     
    
   

    

     

    
    

     

                  time.sleep(
      5)
     
    
   

    

     

    
    

     
            
      continue
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              case = random.randint(
      1,
      100)
     
    
   

    

     

    
    

     
        
      # %5 概率升级
     
    
   

    

     

    
    

     
        
      if case >= 
      85 
      and case < 
      90:
     
    
   

    

     

    
    

     

                  upgrade_champ()
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              time.sleep(
      1)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def close_award_interface(lol_hwnd):
     
    
   

    

     

    
    

     

          ok_box = (lol_hwnd.centerx - 
      100, lol_hwnd.bottom - 
      60, 
      200, 
      40)
     
    
   

    

     

    
    

     

          c = pg.center(ok_box)
     
    
   

    

     

    
    

     

          slow_click(c)
     
    
   

    

     

    
    

     

          move_to_empty_area(lol_hwnd)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def pg_wait_surrender_finish(lol_hwnd):
     
    
   

    

     

    
    

     

          client_title = 
      'League of Legends (TM) Client'
     
    
   

    

     

    
    

     

          times = 
      0
     
    
   

    

     

    
    

     
    
      while 
      True:
     
    
   

    

     

    
    

     

              time.sleep(
      1)
     
    
   

    

     

    
    

     

              times += 
      1
     
    
   

    

     

    
    

     
        
      if pg.getWindowsWithTitle(client_title) == []:
     
    
   

    

     

    
    

     
            
      break
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
        
      if times % 
      10 == 
      0:
     
    
   

    

     

    
    

     

                  print(
      "pg_wait_surrender_finish %d sec, still wait client over!"%times)
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      # 检测结算界面是否打开
     
    
   

    

     

    
    

     
    
      while 
      True:
     
    
   

    

     

    
    

     

              pic = Image.open(
      r'scs\end.jpg')
     
    
   

    

     

    
    

     

              box = pg.locateOnScreen(pic, confidence = 
      0.9)
     
    
   

    

     

    
    

     
        
      if box:
     
    
   

    

     

    
    

     
            
      break
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     

              record_and_print_log(
      "Not Found end.jpg!")
     
    
   

    

     

    
    

     
        
      # 结算界面已打开，但被奖励界面遮挡
     
    
   

    

     

    
    

     
        
      if lol_hwnd.size == (
      1600, 
      900):
     
    
   

    

     

    
    

     

                  record_and_print_log(
      "try to close_award_interface!")
     
    
   

    

     

    
    

     

                  close_award_interface(lol_hwnd)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              time.sleep(
      3)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def pg_play_again(lol_hwnd):
     
    
   

    

     

    
    

     
    
      global box_play_again, box_empty_area
     
    
   

    

     

    
    

     

          center = convert_lol_to_destop_point(get_box_center(box_play_again), lol_hwnd)
     
    
   

    

     

    
    

     

          pg.click(center[
      0], center[
      1], duration = 
      0.3)  
      # 点击再玩一次
     
    
   

    

     

    
    

     

          move_to_empty_area(lol_hwnd)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          time.sleep(
      1)
     
    
   

    

     

    
    

     

          pic = Image.open(
      r'scs\end.jpg')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          pic_find_match = Image.open(
      r'scs\find_match.jpg')
     
    
   

    

     

    
    

     

          box = pg.locateOnScreen(pic_find_match, confidence=
      0.9)
     
    
   

    

     

    
    

     
    
      while 
      not box:
     
    
   

    

     

    
    

     
        
      if pg.locateOnScreen(pic, confidence = 
      0.9) != []:
     
    
   

    

     

    
    

     

                  pg.click(center[
      0], center[
      1], duration = 
      0.3)  
      # 点击再玩一次
     
    
   

    

     

    
    

     

                  move_to_empty_area(lol_hwnd)
     
    
   

    

     

    
    

     
        
      else:
     
    
   

    

     

    
    

     
            
      # 奖励界面遮挡
     
    
   

    

     

    
    

     

                  close_award_interface(lol_hwnd)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              time.sleep(
      1)
     
    
   

    

     

    
    

     

              box = pg.locateOnScreen(pic_find_match, confidence=
      0.9)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def pg_stop_play():
     
    
   

    

     

    
    

     
    
      global AutoPalyFlag
     
    
   

    

     

    
    

     

          AutoPalyFlag = 
      False
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      # 手动结束脚本命令，按Ctrl+Alt+q即可设置停止运行标志
     
    
   

    

     

    
    

     

      kb.add_hotkey(
      'ctrl+alt+q', pg_stop_play)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def pg_main():
     
    
   

    

     

    
    

     
    
      global AutoPalyFlag, log_file
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          w = get_lol_hwnd()
     
    
   

    

     

    
    

     
    
      if 
      not w:
     
    
   

    

     

    
    

     

              print(
      "游戏未启动，请启动游戏后再运行脚本！")
     
    
   

    

     

    
    

     
        
      return 
      False
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          play_times = 
      0
     
    
   

    

     

    
    

     

          start_time = time.localtime()
     
    
   

    

     

    
    

     

          game_time_list = []
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # record_and_print_log("[%s] pg_find_match"%get_time_fmt_str())
     
    
   

    

     

    
    

     
    
      # pg_find_match(w)
     
    
   

    

     

    
    

     
    
      # record_and_print_log("[%s] pg_wait_loading"%get_time_fmt_str())
     
    
   

    

     

    
    

     
    
      # pg_wait_loading(w)
     
    
   

    

     

    
    

     
    
      # record_and_print_log("[%s] pg_quick_wait_quit"%get_time_fmt_str())
     
    
   

    

     

    
    

     
    
      # pg_quick_wait_quit()
     
    
   

    

     

    
    

     
    
      # record_and_print_log("[%s] pg_wait_surrender_finish"%get_time_fmt_str())
     
    
   

    

     

    
    

     
    
      # pg_wait_surrender_finish(w)
     
    
   

    

     

    
    

     
    
      # play_times += 1
     
    
   

    

     

    
    

     
    
      # record_and_print_log("[%s] pg_play_again"%get_time_fmt_str())
     
    
   

    

     

    
    

     
    
      # pg_play_again(w)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      while AutoPalyFlag:
     
    
   

    

     

    
    

     
        
      # 游戏开始时间
     
    
   

    

     

    
    

     

              game_start = time.time()
     
    
   

    

     

    
    

     

              record_and_print_log(
      "[%s] pg_find_match"%get_time_fmt_str())
     
    
   

    

     

    
    

     

              pg_find_match(w)
     
    
   

    

     

    
    

     

              record_and_print_log(
      "[%s] pg_wait_loading"%get_time_fmt_str())
     
    
   

    

     

    
    

     

              pg_wait_loading(w)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              case = random.randint(
      1, 
      3)
     
    
   

    

     

    
    

     
        
      # case = 1
     
    
   

    

     

    
    

     
        
      if case == 
      1:
     
    
   

    

     

    
    

     

                  record_and_print_log(
      "[%s] pg_wait_stage_3_2"%get_time_fmt_str())
     
    
   

    

     

    
    

     

                  pg_wait_stage_3_2()
     
    
   

    

     

    
    

     

                  record_and_print_log(
      "[%s] surrender"%get_time_fmt_str())
     
    
   

    

     

    
    

     

                  surrender()
     
    
   

    

     

    
    

     

                  record_and_print_log(
      "[%s] pg_wait_surrender_finish"%get_time_fmt_str())
     
    
   

    

     

    
    

     
        
      elif case == 
      2:
     
    
   

    

     

    
    

     

                  record_and_print_log(
      "[%s] pg_quick_wait_quit"%get_time_fmt_str())
     
    
   

    

     

    
    

     

                  pg_quick_wait_quit()
     
    
   

    

     

    
    

     
        
      elif case == 
      3:
     
    
   

    

     

    
    

     

                  record_and_print_log(
      "[%s] pg_slow_wait_quit"%get_time_fmt_str())
     
    
   

    

     

    
    

     

                  pg_slow_wait_quit()
     
    
   

    

     

    
    

     

              pg_wait_surrender_finish(w)
     
    
   

    

     

    
    

     

              play_times += 
      1
     
    
   

    

     

    
    

     

              record_and_print_log(
      "[%s] pg_play_again"%get_time_fmt_str())
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
      # 游戏结束时间
     
    
   

    

     

    
    

     

              game_end = time.time()
     
    
   

    

     

    
    

     

              game_time = int(game_end - game_start)
     
    
   

    

     

    
    

     

              game_time_list.append(game_time)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        
      if 
      not AutoPalyFlag:
     
    
   

    

     

    
    

     
            
      break
     
    
   

    

     

    
    

     

              pg_play_again(w)
     
    
   

    

     

    
    

     
        
     
    
   

    

     

    
    

     
    
      # 统计每局时间，写入到文件
     
    
   

    

     

    
    

     
    
      for i 
      in range(len(game_time_list)):
     
    
   

    

     

    
    

     

              seconds = game_time_list[i] % 
      60
     
    
   

    

     

    
    

     

              minutes = int(game_time_list[i] / 
      60)
     
    
   

    

     

    
    

     

              info = 
      "第%d局用时[%d]分[%d]秒"%(i + 
      1, minutes, seconds)
     
    
   

    

     

    
    

     

              record_and_print_log(info)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 输出统计信息
     
    
   

    

     

    
    

     

          end_time = time.localtime()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          record_and_print_log(
      "[%s] 开始挂机"%get_time_fmt_str(start_time))
     
    
   

    

     

    
    

     

          record_and_print_log(
      "[%s] 结束挂机"%get_time_fmt_str(end_time))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          diff_time_sec = time.mktime(end_time) - time.mktime(start_time)
     
    
   

    

     

    
    

     

          t_s = int(diff_time_sec) % 
      60
     
    
   

    

     

    
    

     

          diff_time_sec /= 
      60
     
    
   

    

     

    
    

     
    
      # 总共所用分钟数
     
    
   

    

     

    
    

     

          total_minutes = diff_time_sec
     
    
   

    

     

    
    

     

          t_m = int(diff_time_sec) % 
      60
     
    
   

    

     

    
    

     

          diff_time_sec /= 
      60
     
    
   

    

     

    
    

     

          t_h = int(diff_time_sec)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          average_minutes = total_minutes / play_times
     
    
   

    

     

    
    

     

          t_ave_m = int(average_minutes)
     
    
   

    

     

    
    

     

          t_ave_s = int((average_minutes - t_ave_m) * 
      60)
     
    
   

    

     

    
    

     

          record_and_print_log(
      "共挂机[%d]小时[%d]分钟[%d]秒，挂机[%d]局，平均[%d]分钟[%d]秒一局"%(t_h, t_m, t_s, play_times, t_ave_m, t_ave_s))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          log_file.close()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      True
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == 
      '__main__':
     
    
   

    

     

    
    

     

          pg_main()
     
    
   

    

     

    
    

     

          os.system(
      "pause")
     
    
  

测试程序：win10下打包好的最新程序和截图资源文件：某度网盘  提取码：lek7