Để xây dựng trò chơi, bạn sẽ cần sử dụng nhiều kỹ năng lập trình cốt lõi. Các loại kỹ năng mà bạn sẽ thấy trong lập trình thực tế. Trong quá trình phát triển trò chơi, bạn sẽ sử dụng các biến, vòng lặp, câu lệnh điều kiện, hàm, lập trình hướng đối tượng và toàn bộ các kỹ thuật và thuật toán lập trình
Ngoài ra, bạn sẽ cảm thấy hài lòng khi chơi trò chơi mà mình vừa tạo
Trong hệ sinh thái Python, bạn sẽ tìm thấy một bộ công cụ, thư viện và khung phong phú giúp bạn tạo trò chơi của mình một cách nhanh chóng. Các bài viết, hướng dẫn và khóa học trong phần này sẽ chỉ cho bạn con đường để bắt kịp tốc độ xây dựng trò chơi của riêng bạn bằng Python
Bạn có biết không? . Máy chủ này chạy phiên bản đầy đủ của Python 3, giống như bộ phụ kiện Python 3 của chúng tôi, nhưng cũng hỗ trợ đồ họa, âm thanh và tính tương tác
Hãy thử một số chương trình Python mẫu bên dưới để xem Pygame Trinket có thể làm gì. Đồ trang sức Pygame có sẵn trong Gói cao cấp của chúng tôi
Trong hướng dẫn này, chúng ta sẽ khám phá các chi tiết bên trong và bên ngoài của việc xây dựng bot trò chơi dựa trên Thị giác máy tính bằng Python, bot này sẽ có thể chơi trò chơi Flash nổi tiếng Sushi Go Round. Bạn có thể sử dụng các kỹ thuật được dạy trong hướng dẫn này để tạo bot tự động thử nghiệm các trò chơi trên web của riêng bạn
Xem trước kết quả cuối cùng
Hãy xem kết quả cuối cùng mà chúng ta sẽ hướng tới
thử nghiệm
điều kiện tiên quyết
Hướng dẫn này và tất cả mã trong đó yêu cầu cài đặt thêm một số thư viện Python. Họ cung cấp một gói Python đẹp mắt cho một loạt mã C cấp thấp, giúp giảm bớt đáng kể quy trình và tốc độ viết kịch bản bot
Một số mã và thư viện dành riêng cho Windows. Có thể có các ứng dụng tương đương với Mac hoặc Linux, nhưng chúng tôi sẽ không đề cập đến chúng trong hướng dẫn này
Bạn sẽ cần tải xuống và cài đặt các thư viện sau
- Thư viện hình ảnh Python
- Nặng nề
- PyWin
Tất cả những điều trên đều có trình tự cài đặt; . Tuy nhiên trong thực tế điều này không phải lúc nào cũng xảy ra. Nếu bạn bắt đầu nhận được bất kỳ thông báo
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]5 nào sau khi cài đặt, có thể bạn sẽ cần điều chỉnh Biến môi trường của mình theo cách thủ công. Thông tin thêm về việc điều chỉnh Biến đường dẫn có thể được tìm thấy tại đây
Công cụ cuối cùng mà chúng ta cần là một chương trình sơn phù hợp. Tôi đề nghị Sơn. NET là một tùy chọn miễn phí tuyệt vời, nhưng bất kỳ chương trình nào có thước đo hiển thị số đo của chúng bằng pixel đều có thể được sử dụng
Chúng tôi sẽ sử dụng một vài trò chơi làm ví dụ trên đường đi
Nhân tiện, nếu bạn muốn đi đường tắt, bạn có thể tìm thấy rất nhiều mẫu trò chơi dựa trên trình duyệt để làm việc trên Envato Market
Giới thiệu
Hướng dẫn này được viết để giới thiệu cơ bản về quy trình xây dựng bot chơi trò chơi dựa trên trình duyệt. Cách tiếp cận mà chúng tôi sắp thực hiện có thể hơi khác so với những gì mà hầu hết mọi người mong đợi khi họ nghĩ về bot. Thay vì tạo một chương trình nằm giữa máy khách và máy chủ tiêm mã [như bot Quake hoặc C/S], bot của chúng tôi sẽ hoàn toàn nằm ở 'bên ngoài'. Chúng tôi sẽ dựa vào các kỹ thuật Computer Vision-esque và lệnh gọi Windows API để thu thập thông tin cần thiết và tạo chuyển động
Với cách tiếp cận này, chúng tôi mất đi một chút chi tiết tinh tế và khả năng kiểm soát, nhưng bù lại thời gian phát triển được rút ngắn và tính dễ sử dụng. Tự động hóa một chức năng trò chơi cụ thể có thể được thực hiện trong một vài dòng mã ngắn và một bot chính thức, bắt đầu hoàn thiện [đối với một trò chơi đơn giản] có thể được tạo ra sau vài giờ
Niềm vui của cách tiếp cận nhanh này là khi bạn đã quen với những gì máy tính có thể dễ dàng 'nhìn thấy', bạn sẽ bắt đầu nhìn các trò chơi hơi khác một chút. Một ví dụ điển hình được tìm thấy trong các trò chơi giải đố. Một cấu trúc phổ biến liên quan đến việc khai thác các giới hạn về tốc độ của con người để buộc bạn phải đưa ra một giải pháp kém tối ưu hơn. Thật thú vị [và khá dễ dàng] để 'phá vỡ' những trò chơi này bằng cách viết kịch bản theo các chuyển động mà con người không bao giờ có thể thực hiện được
Các bot này cũng rất hữu ích để thử nghiệm các trò chơi đơn giản - không giống như con người, bot sẽ không cảm thấy nhàm chán khi chơi đi chơi lại cùng một kịch bản
Mã nguồn cho tất cả các ví dụ hướng dẫn, cũng như cho một trong các bot mẫu đã hoàn thành, có thể được tìm thấy tại đây
Chúc vui vẻ
Bước 1. Tạo một dự án Python mới
Trong một thư mục mới, nhấp chuột phải và chọn
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]6
Sau khi thực hiện, đổi tên tệp từ 'Tài liệu văn bản mới' thành 'quickGrab. py' [không có dấu ngoặc kép] và xác nhận rằng bạn muốn thay đổi phần mở rộng tên tệp
Cuối cùng, nhấp chuột phải vào tệp mới tạo của chúng tôi và chọn "Chỉnh sửa bằng IDLE" từ menu ngữ cảnh để khởi chạy trình chỉnh sửa
Bước 2. Thiết lập chụp màn hình đầu tiên của bạn
Chúng ta sẽ bắt đầu làm việc trên bot của mình bằng cách khám phá chức năng lấy màn hình cơ bản. Sau khi thiết lập và chạy, chúng ta sẽ thực hiện từng dòng một, vì hàm này [và nhiều lần lặp lại của nó] sẽ đóng vai trò là xương sống của mã của chúng ta
trong quickgrab. py nhập mã sau
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]
Chạy chương trình này sẽ cung cấp cho bạn ảnh chụp nhanh toàn bộ khu vực màn hình
Mã hiện tại lấy toàn bộ chiều rộng và chiều cao của khu vực màn hình của bạn và lưu nó dưới dạng PNG trong thư mục làm việc hiện tại của bạn
Bây giờ, hãy xem qua mã để xem chính xác nó hoạt động như thế nào
Ba dòng đầu tiên
import ImageGrab import os import time
là những 'báo cáo nhập khẩu' được đặt tên khéo léo. Chúng báo cho Python tải các mô-đun được liệt kê khi chạy. Điều này cho phép chúng tôi truy cập vào các phương thức của họ thông qua cú pháp
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]7
Mô-đun đầu tiên là một phần của Thư viện hình ảnh Python mà chúng tôi đã cài đặt trước đó. Như tên gọi của nó, nó cung cấp cho chúng tôi chức năng thu hút màn hình cơ bản mà bot của chúng tôi sẽ dựa vào
Dòng thứ hai nhập Mô-đun HĐH [Hệ điều hành]. Điều này mang lại cho chúng tôi khả năng dễ dàng điều hướng xung quanh các thư mục của hệ điều hành. Nó sẽ hữu ích khi chúng ta bắt đầu sắp xếp nội dung vào các thư mục khác nhau
Lần nhập cuối cùng này là mô-đun Thời gian tích hợp. Sử dụng tốt điều này chủ yếu để đóng dấu thời gian hiện tại vào ảnh chụp nhanh, nhưng nó có thể rất hữu ích như một bộ đếm thời gian cho các bot cần các sự kiện được kích hoạt trong một số giây nhất định
Bốn dòng tiếp theo tạo thành trung tâm của chức năng
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]8 của chúng tôi________số 8
Dòng đầu tiên
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]9 xác định tên của chức năng của chúng tôi. Dấu ngoặc đơn trống có nghĩa là nó không mong đợi đối số
Dòng 2,
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]00 gán một bộ dữ liệu trống cho một biến có tên là "hộp". Chúng tôi sẽ lấp đầy điều này với các đối số trong bước tiếp theo
Dòng 3,
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]01 tạo ảnh chụp toàn màn hình của bạn và trả về hình ảnh RGB cho phiên bản
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]02
Dòng 4 có thể hơi phức tạp nếu bạn không quen với cách thức hoạt động của mô-đun
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]03. Phần đầu tiên
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]04 gọi phương thức "save" từ lớp Image. Nó mong đợi hai đối số. Đầu tiên là vị trí lưu tệp và thứ hai là định dạng tệp
Ở đây chúng tôi đặt vị trí bằng cách gọi đầu tiên
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]05. Cái này lấy thư mục hiện tại mà mã đang được chạy từ đó và trả về nó dưới dạng một chuỗi. Tiếp theo chúng ta thêm một
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]06. Điều này sẽ được sử dụng ở giữa mỗi đối số mới để nối tất cả các chuỗi lại với nhau
Phần tiếp theo
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]07 đặt cho tệp của chúng tôi một tên mô tả đơn giản. [Vì dấu gạch chéo ngược là một ký tự thoát trong Python nên chúng tôi phải thêm hai ký tự để tránh hủy bỏ một trong các chữ cái của chúng tôi]
Tiếp theo là bit lông.
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]08. Điều này tận dụng các phương thức Type tích hợp sẵn của Python. Chúng tôi sẽ giải thích phần này bằng cách làm việc từ trong ra ngoài
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]09 trả về số giây kể từ Epoch, được cung cấp dưới dạng Float kiểu. Vì chúng tôi đang tạo tên tệp nên chúng tôi không thể có số thập phân trong đó, vì vậy trước tiên chúng tôi chuyển đổi nó thành số nguyên bằng cách gói nó trong ____200. Điều này giúp chúng ta kết thúc, nhưng Python không thể nối loại
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]01 với loại
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]02, vì vậy, bước cuối cùng là bọc mọi thứ trong hàm
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]03 để cung cấp cho chúng tôi dấu thời gian đẹp có thể sử dụng được cho tên tệp. Từ đây, tất cả những gì còn lại là thêm phần mở rộng như một phần của chuỗi.
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]04 và chuyển đối số thứ hai lại là loại của tiện ích mở rộng.
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]05
Phần cuối cùng của mã của chúng tôi định nghĩa hàm
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]06 và yêu cầu nó gọi hàm
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]8 bất cứ khi nào nó chạy
Và ở đây, cuối cùng, là một quy ước Python kiểm tra xem tập lệnh có phải là cấp cao nhất hay không và nếu có thì cho phép nó chạy. Được dịch, nó chỉ đơn giản có nghĩa là nó chỉ thực thi
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]06 nếu nó được chạy bởi chính nó. Mặt khác - ví dụ: nếu nó được tải dưới dạng một mô-đun bởi một tập lệnh Python khác - nó chỉ cung cấp các phương thức của nó thay vì thực thi mã của nó
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]9
Bước 3. Hộp giới hạn
Hàm
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]09 chấp nhận một đối số xác định hộp giới hạn. Đây là một bộ tọa độ theo mẫu của [x,y,x,y] trong đó,
- Cặp giá trị đầu tiên [
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]
10 xác định góc trên cùng bên trái của hộp - Cặp thứ hai
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]
11] xác định phía dưới bên phải
Kết hợp những thứ này cho phép chúng tôi chỉ sao chép phần màn hình mà chúng tôi cần
Hãy áp dụng điều này vào thực tế
Đối với ví dụ này, chúng tôi sẽ sử dụng trò chơi có tên Sushi Go Round. [khá ghiền. Mày đã được cảnh báo. ] Mở trò chơi trong tab mới và chụp ảnh nhanh bằng mã
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]8 hiện có của chúng tôi
Ảnh chụp toàn màn hình
Bước 4. Lấy tọa độ
Bây giờ là lúc bắt đầu khai thác một số tọa độ cho hộp giới hạn của chúng tôi
Mở ảnh chụp nhanh gần đây nhất của bạn trong trình chỉnh sửa hình ảnh
Vị trí [0,0] luôn nằm ở góc trên cùng bên trái của hình ảnh. Chúng tôi muốn đệm tọa độ x và y để chức năng chụp nhanh mới của chúng tôi đặt [0,0] ở góc ngoài cùng bên trái của khu vực chơi của trò chơi
Những lý do cho điều này là gấp đôi. Đầu tiên, nó làm cho việc tìm tọa độ trong trò chơi dễ dàng hơn nhiều khi chúng tôi chỉ cần điều chỉnh các giá trị liên quan đến khu vực chơi so với toàn bộ khu vực độ phân giải màn hình của bạn. Thứ hai, chiếm một phần nhỏ hơn của màn hình giúp giảm chi phí xử lý cần thiết. Chụp toàn màn hình tạo ra khá nhiều dữ liệu, điều này có thể gây khó khăn cho việc duyệt qua nó nhiều lần mỗi giây
Nếu chưa hoàn tất, hãy bật hiển thị thước kẻ trong trình chỉnh sửa của bạn và phóng to ở góc trên cùng của khu vực phát cho đến khi bạn có thể xem chi tiết các pixel
Di chuột qua pixel đầu tiên của khu vực chơi và kiểm tra tọa độ hiển thị trên thước. Đây sẽ là hai giá trị đầu tiên của Box Tuple của chúng tôi. Trên máy cụ thể của tôi, các giá trị này là
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]13
Điều hướng đến cạnh dưới của khu vực chơi để lấy cặp tọa độ dưới cùng
Điều này cho thấy tọa độ của 796 và 641. Kết hợp những thứ này với cặp trước đó của chúng tôi sẽ tạo ra một hộp có tọa độ là
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]14
Hãy thêm mã này vào mã của chúng tôi
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]
Trong dòng 6, chúng tôi đã cập nhật bộ dữ liệu để giữ tọa độ của khu vực chơi
Lưu và chạy mã. Mở hình ảnh mới lưu và bạn sẽ thấy
Thành công. Một cách hoàn hảo của khu vui chơi. Không phải lúc nào chúng ta cũng cần thực hiện kiểu tìm kiếm tọa độ chuyên sâu này. Sau khi truy cập win32api, chúng ta sẽ xem xét một số phương pháp nhanh hơn để đặt tọa độ khi không cần độ chính xác hoàn hảo của pixel
Bước 5. Lên kế hoạch trước cho sự linh hoạt
Hiện tại, chúng tôi đã mã hóa cứng các tọa độ liên quan đến thiết lập hiện tại của chúng tôi, giả sử trình duyệt và độ phân giải của chúng tôi. Nói chung, đó là một ý tưởng tồi đối với các tọa độ mã cứng theo cách này. Ví dụ: nếu chúng tôi muốn chạy mã trên một máy tính khác - hoặc giả sử, một quảng cáo mới trên trang web thay đổi vị trí của khu vực chơi một chút - chúng tôi sẽ phải sửa tất cả các cuộc gọi tọa độ của mình theo cách thủ công và cẩn thận
Vì vậy, chúng ta sẽ tạo hai biến mới.
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]15 và
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]16. Chúng sẽ được sử dụng để lưu trữ mối quan hệ giữa khu vực trò chơi và phần còn lại của màn hình. Điều này sẽ giúp chuyển mã từ nơi này sang nơi khác rất dễ dàng vì mọi tọa độ mới sẽ liên quan đến hai biến toàn cục mà chúng ta sẽ tạo và để điều chỉnh các thay đổi trong khu vực màn hình, tất cả những gì cần thiết là đặt lại hai biến này
Vì chúng tôi đã thực hiện các phép đo nên việc cài đặt các miếng đệm cho hệ thống hiện tại của chúng tôi rất đơn giản. Chúng tôi sẽ đặt các miếng đệm để lưu trữ vị trí của pixel đầu tiên bên ngoài khu vực chơi. Từ cặp tọa độ x, y đầu tiên trong bộ dữ liệu
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]17 của chúng ta, hãy trừ đi một
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]18 cho mỗi giá trị. Vì vậy,
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]19 trở thành
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]20 và
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]21 trở thành
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]22
Hãy thêm mã này vào mã của chúng tôi
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]0
Bây giờ những giá trị này đã được thiết lập, chúng ta sẽ bắt đầu điều chỉnh hộp tuple liên quan đến các giá trị này
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]0
Đối với cặp thứ hai, trước tiên chúng ta sẽ trừ các giá trị của các miếng đệm [156 và 345] khỏi tọa độ [796, 825], sau đó sử dụng các giá trị đó ở cùng định dạng
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]23
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]1
Ở đây tọa độ
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]24 trở thành 640 [769-156] và
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]25 trở thành 480 [825-345]
Thoạt nghe có vẻ hơi thừa, nhưng thực hiện bước bổ sung này sẽ đảm bảo việc bảo trì dễ dàng trong tương lai
Bước 6. Tạo một chuỗi tài liệu
Trước khi tiến xa hơn, chúng tôi sẽ tạo một chuỗi tài liệu ở đầu dự án của chúng tôi. Vì hầu hết mã của chúng tôi sẽ dựa trên các tọa độ màn hình cụ thể và mối quan hệ với các tọa độ, điều quan trọng là phải biết các trường hợp mà mọi thứ sẽ sắp xếp chính xác. Chẳng hạn, những thứ như độ phân giải hiện tại, trình duyệt, thanh công cụ được bật [vì chúng thay đổi khu vực trình duyệt] và mọi điều chỉnh cần thiết để căn giữa khu vực phát trên màn hình, tất cả đều ảnh hưởng đến vị trí tương đối của tọa độ. Có tất cả những tài liệu này giúp ích rất nhiều cho quá trình khắc phục sự cố khi chạy mã của bạn trên nhiều trình duyệt và máy tính
Một điều cuối cùng cần lưu ý là không gian quảng cáo luôn thay đổi trên các trang web trò chơi phổ biến. Nếu tất cả các cuộc gọi lấy của bạn đột nhiên ngừng hoạt động như mong đợi, thì một bổ sung mới thay đổi một chút trên màn hình là một lựa chọn tốt
Ví dụ, tôi thường có các nhận xét sau ở đầu mã Python của mình
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]2
Bỏ tất cả thông tin này vào đầu tệp Python của bạn giúp kiểm tra lại tất cả các cài đặt và căn chỉnh màn hình của bạn nhanh chóng và dễ dàng mà không cần phải nghiền ngẫm mã của bạn để cố nhớ nơi bạn đã lưu một tọa độ x cụ thể đó
Bước 7. Biến import ImageGrab
import os
import time
def screenGrab[]:
box = []
im = ImageGrab.grab[]
im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] +
'.png', 'PNG']
def main[]:
screenGrab[]
if __name__ == '__main__':
main[]
26 thành một công cụ hữu ích
Tại thời điểm này, chúng ta sẽ rẽ nhánh dự án của mình, tạo hai tệp. một để chứa tất cả mã bot của chúng tôi và cái còn lại hoạt động như một tiện ích chụp màn hình chung. Chúng ta sẽ chụp rất nhiều ảnh màn hình khi tìm kiếm tọa độ, vì vậy việc có một mô-đun riêng sẵn sàng hoạt động sẽ giúp mọi thứ nhanh hơn rất nhiều
Lưu và đóng dự án hiện tại của chúng tôi
Trong thư mục của bạn, nhấp chuột phải vào
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]26 và chọn 'sao chép' từ menu
Bây giờ, nhấp chuột phải và chọn 'dán' từ menu
Chọn tệp đã sao chép và đổi tên thành 'mã. py'
Từ giờ trở đi, tất cả các bổ sung và thay đổi mã mới sẽ được thực hiện trong mã. py. lấy nhanh. py bây giờ sẽ hoạt động hoàn toàn như một công cụ chụp nhanh. Chúng ta chỉ cần thực hiện một sửa đổi cuối cùng
Thay đổi phần mở rộng tệp từ. py, để. pyw và xác nhận các thay đổi
Tiện ích mở rộng này yêu cầu Python chạy tập lệnh mà không cần khởi chạy bảng điều khiển. Vì vậy, bây giờ, quickGrab. pyw sống đúng với tên gọi của nó. Nhấp đúp vào tệp và nó sẽ lặng lẽ thực thi mã của nó ở chế độ nền và lưu ảnh chụp nhanh vào thư mục làm việc của bạn
Giữ cho trò chơi mở ở chế độ nền [hãy nhớ tắt tiếng trò chơi trước khi âm nhạc được lặp đi lặp lại khiến bạn phát điên]; . Chúng tôi có thêm một vài khái niệm/công cụ để giới thiệu trước khi bắt đầu kiểm soát mọi thứ trên màn hình
Bước 8. import ImageGrab
import os
import time
def screenGrab[]:
box = []
im = ImageGrab.grab[]
im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] +
'.png', 'PNG']
def main[]:
screenGrab[]
if __name__ == '__main__':
main[]
28 - Tổng quan ngắn gọn
Làm việc với
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]29 ban đầu có thể hơi khó khăn. Nó bao bọc mã Windows C cấp thấp - rất may là được ghi lại rất rõ ràng ở đây, nhưng hơi giống một mê cung để điều hướng qua vài lượt đi đầu tiên của bạn
Trước khi chúng tôi bắt đầu viết bất kỳ hành động hữu ích nào, chúng tôi sẽ xem xét kỹ một số chức năng API mà chúng tôi sẽ dựa vào. Khi chúng tôi hiểu rõ về từng tham số, sẽ dễ dàng điều chỉnh chúng để phục vụ bất kỳ mục đích nào chúng tôi cần trong trò chơi
import ImageGrab import os import time60
import ImageGrab import os import time6
Tham số đầu tiên
import ImageGrab import os import time61 xác định "hành động" của chuột. Nó kiểm soát những thứ như chuyển động, nhấp, cuộn, v.v.
Danh sách sau đây hiển thị các tham số phổ biến nhất được sử dụng trong khi chuyển động tập lệnh
import ImageGrab import os import time61
import ImageGrab import os import time
63import ImageGrab import os import time
64import ImageGrab import os import time
65import ImageGrab import os import time
66import ImageGrab import os import time
67import ImageGrab import os import time
68import ImageGrab import os import time
69
Mỗi tên là tự giải thích. Nếu bạn muốn gửi một nhấp chuột phải ảo, bạn sẽ chuyển
import ImageGrab import os import time67 cho tham số
import ImageGrab import os import time61
Hai tham số tiếp theo,
import ImageGrab import os import time02 và
import ImageGrab import os import time03, mô tả vị trí tuyệt đối của chuột dọc theo trục x và y. Mặc dù chúng tôi có thể sử dụng các tham số này để viết kịch bản chuyển động của chuột, nhưng chúng sử dụng hệ tọa độ khác với hệ tọa độ chúng tôi đang sử dụng. Vì vậy, chúng tôi sẽ đặt chúng thành 0 và dựa vào một phần khác của API cho nhu cầu di chuyển chuột của chúng tôi
Tham số thứ tư là
import ImageGrab import os import time04. Hàm này được sử dụng nếu [và chỉ khi]
import ImageGrab import os import time61 chứa
import ImageGrab import os import time06. Nếu không thì có thể được bỏ qua hoặc đặt thành không.
import ImageGrab import os import time04 chỉ định mức độ di chuyển trên con lăn chuột của bạn
Một ví dụ nhanh để củng cố các kỹ thuật này
Nếu chúng ta tưởng tượng một trò chơi có hệ thống chọn vũ khí tương tự như Half-Life 2 - nơi vũ khí có thể được chọn bằng cách xoay con lăn chuột - chúng ta sẽ nghĩ ra chức năng sau để sàng lọc danh sách vũ khí
import ImageGrab import os import time0
Ở đây, chúng tôi muốn mô phỏng việc cuộn con lăn chuột để điều hướng danh sách vũ khí lý thuyết của mình, vì vậy chúng tôi đã chuyển 'hành động' của
import ImageGrab import os import time08 cho dwFlag. Chúng tôi không cần
import ImageGrab import os import time02 hoặc
import ImageGrab import os import time03, dữ liệu vị trí, vì vậy chúng tôi để các giá trị này được đặt thành 0 và chúng tôi muốn cuộn một lần nhấp theo hướng về phía trước cho mỗi 'vũ khí' trong danh sách, vì vậy chúng tôi đã chuyển số nguyên 120 cho dwData [mỗi
Như bạn có thể thấy, làm việc với
import ImageGrab import os import time11 chỉ đơn giản là đặt các đối số phù hợp vào đúng vị trí. Bây giờ chúng ta hãy chuyển sang một số chức năng có thể sử dụng được
Bước 5. Bấm chuột cơ bản
Chúng tôi sẽ thực hiện ba chức năng mới. Một chức năng nhấp chuột trái chung và hai chức năng xử lý các trạng thái xuống và lên cụ thể
Mở
import ImageGrab import os import time12 bằng IDLE và thêm phần sau vào danh sách các câu lệnh nhập của chúng tôi
import ImageGrab import os import time1
Như trước đây, điều này cho phép chúng tôi truy cập vào nội dung của mô-đun thông qua cú pháp
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]7
Tiếp theo, chúng ta sẽ thực hiện chức năng nhấp chuột đầu tiên
import ImageGrab import os import time2
Nhớ lại rằng tất cả những gì chúng ta đang làm ở đây là gán một 'hành động' cho đối số đầu tiên của
import ImageGrab import os import time11. Chúng tôi không cần chuyển bất kỳ thông tin vị trí nào, vì vậy chúng tôi sẽ để lại các tham số tọa độ ở [0,0] và chúng tôi không cần gửi bất kỳ thông tin bổ sung nào, vì vậy
import ImageGrab import os import time04 sẽ bị bỏ qua. Hàm
import ImageGrab import os import time16 yêu cầu Python tạm dừng thực thi trong khoảng thời gian được chỉ định trong ngoặc đơn. Chúng tôi sẽ thêm những thứ này thông qua mã của chúng tôi, thường trong một khoảng thời gian rất ngắn. Nếu không có những thứ này, tiếng 'nhấp chuột' có thể vượt lên và kích hoạt trước khi các menu có cơ hội cập nhật
Vì vậy, những gì chúng tôi đã thực hiện ở đây là nhấp chuột trái nói chung. Một lần nhấn, một lần phát hành. Chúng tôi sẽ dành phần lớn thời gian cho cái này, nhưng chúng tôi sẽ tạo thêm hai biến thể nữa
Hai bước tiếp theo hoàn toàn giống nhau, nhưng bây giờ mỗi bước được chia thành chức năng riêng của nó. Chúng sẽ được sử dụng khi chúng ta cần giữ chuột trong một khoảng thời gian dài [để kéo, bắn, v.v. ]
import ImageGrab import os import time3
Bước 9. Di chuyển chuột cơ bản
Với việc nhấp chuột ngoài lề, tất cả những gì còn lại là di chuyển chuột trên màn hình
Thêm các chức năng sau vào
import ImageGrab import os import time12
import ImageGrab import os import time4
Hai chức năng này phục vụ các mục đích rõ ràng khác nhau. Đầu tiên sẽ được sử dụng cho kịch bản chuyển động trong chương trình. Nhờ các quy ước đặt tên tuyệt vời, phần thân của hàm thực hiện chính xác như hàm ý của
import ImageGrab import os import time18. Gọi hàm này sẽ đặt chuột tới tọa độ được truyền cho nó dưới dạng bộ dữ liệu
import ImageGrab import os import time19. Lưu ý rằng chúng tôi đã thêm vào các miếng đệm
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]24 và
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]25;
Thứ hai là một công cụ đơn giản mà chúng ta sẽ sử dụng khi chạy Python một cách tương tác. Nó in ra bàn điều khiển vị trí hiện tại của chuột dưới dạng bộ dữ liệu
import ImageGrab import os import time19. Điều này giúp tăng tốc đáng kể quá trình điều hướng qua các menu mà không cần phải chụp ảnh nhanh và lấy thước ra. Không phải lúc nào chúng tôi cũng có thể sử dụng tính năng này vì một số hoạt động của chuột sẽ cần phải dành riêng cho từng pixel, nhưng khi có thể, đó là một trình tiết kiệm thời gian tuyệt vời
Trong bước tiếp theo, chúng tôi sẽ đưa một số kỹ thuật mới này vào sử dụng và bắt đầu điều hướng các menu trong trò chơi. Nhưng trước khi thực hiện, hãy xóa nội dung hiện tại của
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]06 trong
import ImageGrab import os import time12 và thay thế bằng
import ImageGrab import os import time25. Chúng ta sẽ làm việc với lời nhắc tương tác cho bước tiếp theo, vì vậy chúng ta sẽ không cần hàm
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]8
Bước 10. Điều hướng menu trò chơi
Trong phần này và một vài bước tiếp theo, chúng tôi sẽ cố gắng thu thập càng nhiều tọa độ sự kiện càng tốt bằng cách sử dụng phương pháp
import ImageGrab import os import time27 của chúng tôi. Sử dụng nó, chúng ta sẽ có thể nhanh chóng xây dựng mã cho những thứ như điều hướng menu, dọn bàn và chế biến thức ăn. Sau khi chúng tôi có những bộ này, vấn đề chỉ là kết nối chúng vào logic của bot
Bắt đầu nào. Lưu và chạy mã của bạn để hiển thị trình bao Python. Vì chúng tôi đã thay thế phần thân của
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]06 bằng
import ImageGrab import os import time25 ở bước cuối cùng, bạn sẽ thấy một vỏ trống khi chạy
Bây giờ, trước khi chúng ta đến phần có thể chơi được của trò chơi, có bốn menu ban đầu mà chúng ta cần phải vượt qua. Chúng như sau
- Nút "phát" ban đầu
- nút "tiếp tục" trên iPhone
- Hướng dẫn nút "Bỏ qua"
- Mục tiêu hôm nay nút "Tiếp tục"
Chúng ta sẽ cần lấy tọa độ cho từng thứ này và thêm chúng vào một hàm mới có tên là
import ImageGrab import os import time30. Định vị vỏ IDLE để bạn có thể nhìn thấy cả vỏ và khu vực chơi. Nhập hàm
import ImageGrab import os import time27 nhưng chưa nhấn quay lại; . Đảm bảo chưa nhấp vì chúng tôi muốn tiêu điểm vẫn ở trong trình bao. Di chuột qua mục menu và bây giờ nhấn phím quay lại. Thao tác này sẽ lấy vị trí hiện tại của chuột và in ra bảng điều khiển một bộ chứa các giá trị
import ImageGrab import os import time19. Lặp lại điều này cho ba menu còn lại
Bắt_đầu_dây
Để Shell mở và sắp xếp nó để bạn có thể nhìn thấy nó cũng như trình chỉnh sửa IDLE. Bây giờ chúng ta sẽ thêm hàm
import ImageGrab import os import time30 và điền vào nó các tọa độ mới thu được
import ImageGrab import os import time5
Bây giờ chúng tôi có một chức năng nhỏ gọn đẹp mắt để gọi khi bắt đầu mỗi trò chơi. Nó đặt vị trí con trỏ cho từng vị trí menu mà chúng tôi đã xác định trước đó, sau đó ra lệnh cho chuột nhấp vào.
import ImageGrab import os import time16 yêu cầu Python tạm dừng thực thi trong 1/10 giây giữa mỗi lần nhấp, điều này giúp các menu có đủ thời gian để cập nhật giữa các lần
Lưu và chạy mã của bạn và bạn sẽ thấy kết quả tương tự như thế này
bắt đầu trò chơi
Là một người yếu ớt, tôi mất hơn một giây để điều hướng tất cả các menu bằng tay, nhưng bot của chúng tôi hiện có thể làm điều đó trong khoảng. 4 giây. Không xấu cả
Bước 11. Lấy tọa độ thực phẩm
Bây giờ chúng ta sẽ lặp lại quy trình tương tự cho từng nút này
Một lần nữa, trong trình bao Python, nhập
import ImageGrab import os import time27, di chuột qua hộp thực phẩm bạn cần và nhấn phím Enter để thực hiện lệnh
Như một tùy chọn để tăng tốc mọi thứ hơn nữa, nếu bạn có màn hình thứ hai hoặc có thể sắp xếp vỏ trăn theo cách mà bạn có thể nhìn thấy nó cũng như khu vực trò chơi, thay vì nhập và chạy
import ImageGrab import os import time27 mỗi khi chúng tôi cần . Sử dụng phương pháp
import ImageGrab import os import time38 để tạm dừng thực thi đủ lâu để bạn di chuyển chuột đến vị trí tiếp theo cần tọa độ
Đây là vòng lặp
import ImageGrab import os import time37 đang hoạt động
food_cords
Chúng tôi sẽ tạo một lớp mới có tên là
import ImageGrab import os import time40 và sử dụng nó để lưu trữ tất cả các giá trị tọa độ mà chúng tôi thu thập được. Có thể gọi
import ImageGrab import os import time41 mang lại lợi thế về khả năng đọc rất lớn so với việc chuyển trực tiếp tọa độ tới
import ImageGrab import os import time42. Như một tùy chọn, bạn cũng có thể lưu trữ mọi thứ trong một
import ImageGrab import os import time43, nhưng tôi thấy cú pháp của lớp thú vị hơn
import ImageGrab import os import time6
Chúng tôi sẽ lưu trữ rất nhiều tọa độ của mình trong lớp này và sẽ có một số trùng lặp, do đó, việc thêm tiền tố '
import ImageGrab import os import time44' cho chúng tôi biết rằng chúng tôi đang đề cập đến các địa điểm thực phẩm, thay vì, ví dụ, một địa điểm trong điện thoại
Chúng tôi sẽ trở lại với những điều này trong một chút. Có thêm một chút săn phối hợp để làm
Bước 12. Lấy tọa độ mảng trống
Mỗi khi khách ăn xong, họ để lại một đĩa cần phải bấm vào để lấy ra. Vì vậy, chúng ta cũng cần lấy vị trí của các đĩa trống
Tôi đã đánh dấu vị trí của họ bằng một chữ 'X' khổng lồ màu đỏ. Lặp lại mô hình tương tự như trong hai bước cuối cùng để có được tọa độ của chúng. Lưu trữ chúng trong chuỗi bình luận ngay bây giờ
import ImageGrab import os import time7
Chúng ta đang đến gần. Chỉ còn một vài bước thiết lập sơ bộ nữa trước khi chúng ta bắt đầu những điều thực sự thú vị
Bước 13. Lấy tọa độ điện thoại
Ok, đây sẽ là tập tọa độ cuối cùng mà chúng ta phải khai thác theo cách cụ thể này
Cái này có nhiều thứ hơn để theo dõi, vì vậy bạn có thể muốn thực hiện nó bằng cách gọi hàm
import ImageGrab import os import time27 theo cách thủ công thay vì phương thức vòng lặp
import ImageGrab import os import time37 đã sử dụng trước đó. Dù bằng cách nào, chúng ta sẽ xem qua tất cả các menu của điện thoại để lấy tọa độ cho từng mục
Cái này liên quan nhiều hơn một chút vì để đến được một trong những màn hình mua hàng mà chúng tôi cần, bạn cần có đủ tiền để thực sự mua thứ gì đó. Vì vậy, bạn sẽ cần làm một vài miếng sushi trước khi bắt đầu công việc săn bắn tọa độ. Tôi tin rằng nhiều nhất bạn sẽ phải làm hai cuộn sushi. Điều đó sẽ giúp bạn có đủ tiền để mua một ít gạo, điều này sẽ đưa chúng ta đến màn hình mà chúng ta cần
Có sáu menu chúng ta phải vượt qua
- Điện thoại
- Thực đơn ban đầu
- toppings
- Cơm
- Đang chuyển hàng
Chúng tôi cần lấy tọa độ cho mọi thứ trừ Sake [mặc dù bạn có thể nếu muốn. Tôi thấy bot hoạt động tốt khi không có nó. Tôi sẵn sàng hy sinh đánh giá không tốt trong trò chơi thường xuyên để không phải viết mã logic. ]
Lấy tọa độ
phone_cords
Chúng tôi sẽ thêm tất cả những thứ này vào lớp Cord của chúng tôi. Chúng tôi sẽ sử dụng tiền tố '______547' để biểu thị rằng các loại thực phẩm là điện thoại>các món trên thực đơn
import ImageGrab import os import time8
Được rồi. Cuối cùng chúng tôi đã khai thác tất cả các giá trị tọa độ mà chúng tôi cần. Vì vậy, hãy bắt đầu làm một cái gì đó hữu ích
Bước 14. dọn bàn
Chúng ta sẽ lấy các tọa độ đã ghi trước đó và sử dụng chúng để điền vào một hàm gọi là clear_tables[]
import ImageGrab import os import time9
Như bạn có thể thấy, hàm này ít nhiều trông giống hàm
import ImageGrab import os import time30 trước đó của chúng ta. Một vài khác biệt nhỏ
Chúng tôi không có chức năng
import ImageGrab import os import time38 ở giữa các sự kiện nhấp chuột khác nhau. Chúng tôi không phải đợi bất kỳ menu nào cập nhật, vì vậy chúng tôi không phải điều chỉnh tốc độ nhấp chuột của mình
Tuy nhiên, chúng tôi có một
import ImageGrab import os import time38 dài ở cuối. Mặc dù không bắt buộc nghiêm ngặt, nhưng thật tuyệt khi thêm các khoảng dừng không thường xuyên này khi thực thi vào mã của chúng tôi, một khoảng thời gian vừa đủ để cho chúng tôi thời gian thoát khỏi vòng lặp chính của bot theo cách thủ công nếu cần [chúng tôi sẽ đề cập đến]. Nếu không, thứ đó sẽ tiếp tục chiếm lấy vị trí chuột của bạn hết lần này đến lần khác và bạn sẽ không thể chuyển trọng tâm sang trình bao đủ lâu để dừng tập lệnh - điều này có thể khiến bạn buồn cười hai hoặc ba lần đầu tiên khi bạn vật lộn với một con chuột
Vì vậy, hãy đảm bảo thêm một số khoảng dừng đáng tin cậy vào bot của riêng bạn
clear_tables
Bước 15. Làm Sushi
Điều đầu tiên chúng ta cần làm là học cách làm sushi. Nhấp vào sách công thức để mở hướng dẫn sử dụng. Tất cả các loại sushi gặp trong suốt trò chơi sẽ được tìm thấy trong các trang của nó. Tôi sẽ lưu ý ba điều đầu tiên bên dưới, nhưng tôi để bạn lập danh mục phần còn lại
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']0
Bây giờ chúng ta sẽ thiết lập một hàm sẽ chấp nhận một đối số cho "loại sushi" và sau đó lắp ráp các thành phần thích hợp dựa trên giá trị đã truyền
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']1
Chức năng này giống như tất cả các chức năng khác nhưng với một thay đổi nhỏ. thay vì chuyển tọa độ trực tiếp, chúng tôi gọi chúng là thuộc tính từ lớp
import ImageGrab import os import time40 của chúng tôi
Hàm
import ImageGrab import os import time52 được gọi ở cuối mỗi quy trình làm sushi. Điều này nhấp vào tấm thảm để cuộn sushi mà chúng ta vừa lắp ráp. Hãy xác định hàm đó ngay bây giờ
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']2
Chúng ta hãy xem qua cuộc gọi ________ 542 này vì nó được ghép lại với nhau một chút. Chúng tôi truy cập giá trị đầu tiên của bộ dữ liệu
import ImageGrab import os import time54 bằng cách thêm
import ImageGrab import os import time55 vào cuối thuộc tính. Nhớ lại rằng đây là giá trị
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]24 của chúng tôi. Để nhấp vào thảm, chúng tôi chỉ cần điều chỉnh các giá trị
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]24 của mình theo một số ít pixel, vì vậy chúng tôi thêm 40 vào tọa độ
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]24 hiện tại, sau đó chuyển
import ImageGrab import os import time59 sang
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]25. Điều này thay đổi vị trí
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]24 của chúng tôi vừa đủ sang bên phải để cho phép chúng tôi kích hoạt thảm
Lưu ý rằng sau cuộc gọi
import ImageGrab import os import time52, chúng tôi có một
import ImageGrab import os import time63. Thảm mất khá nhiều thời gian để cuộn và không thể nhấp vào các mục thực phẩm trong khi hoạt ảnh của chúng đang chạy, vì vậy bạn chỉ cần đợi
make_food
Bước 16. Điều hướng Menu Điện thoại
Trong bước này, chúng tôi sẽ đặt tất cả
import ImageGrab import os import time42 để trỏ đến các mục menu thích hợp, nhưng bây giờ chúng tôi sẽ để nó ở đó. Đây là một phần của chương trình sẽ được bao bọc và kiểm soát bởi logic của bot. Chúng tôi sẽ xem xét lại chức năng này sau khi nhận được một vài kỹ thuật mới trong vành đai của chúng tôi
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']3
Đó là nó cho bước này. Chúng tôi sẽ làm nhiều hơn với điều này sau
giới thiệu ngắn gọn. Làm cho máy tính nhìn thấy
Bây giờ chúng ta đang đi đến những phần rất thú vị. Chúng ta sẽ bắt đầu xem xét cách làm cho máy tính 'nhìn thấy' các sự kiện trên màn hình. Đây là một phần rất thú vị của quy trình và là một phần rất dễ bị cuốn vào suy nghĩ về
Một phần thú vị khác của việc xây dựng bot là cuối cùng bot có thể cung cấp cho chúng tôi, các lập trình viên, đủ thông tin mà không cần phải làm thêm về tầm nhìn. Ví dụ: trong trường hợp của bot Sushi, khi chúng tôi chạy ở cấp độ đầu tiên, bot sẽ đưa ra đủ dữ liệu chính xác về những gì đang xảy ra trên màn hình mà tất cả những gì chúng tôi phải làm từ thời điểm đó là lấy dữ liệu mà nó "nhìn thấy"
Một phần quan trọng khác của việc xây dựng bot là tìm hiểu trò chơi, biết những giá trị nào bạn cần theo dõi và những giá trị nào bạn có thể bỏ qua. Chẳng hạn, chúng tôi sẽ không nỗ lực theo dõi tiền mặt. Nó chỉ là một cái gì đó cuối cùng không liên quan đến bot. Tất cả những gì nó cần biết là liệu nó có đủ thức ăn để tiếp tục làm việc hay không. Vì vậy, thay vì theo dõi tổng số tiền, nó chỉ đơn giản là kiểm tra xem liệu nó có đủ khả năng mua một thứ gì đó hay không, bất kể giá cả, bởi vì khi tính toán trong trò chơi, bạn chỉ mất vài giây trước khi có thể mua thêm một thứ gì đó. Vì vậy, nếu nó không đủ khả năng ngay bây giờ, nó sẽ thử lại sau vài giây
Điều này đưa tôi đến điểm cuối cùng của tôi. Đó là phương pháp vũ phu so với phương pháp tao nhã. Thuật toán tầm nhìn mất thời gian xử lý có giá trị. Việc kiểm tra nhiều điểm ở nhiều khu vực khác nhau trong khu vực chơi có thể nhanh chóng ăn mòn hiệu suất bot của bạn, do đó, câu hỏi đặt ra là "bot có cần biết liệu _______ đã xảy ra hay chưa?"
Ví dụ, một khách hàng trong trò chơi Sushi có thể được coi là có bốn trạng thái. không có mặt, chờ đợi, ăn và ăn xong. Khi hoàn thành, họ để lại một đĩa trống nhấp nháy phía sau. Tôi có thể sử dụng sức mạnh xử lý để kiểm tra tất cả các vị trí tấm bằng cách chụp tất cả sáu vị trí tấm và sau đó kiểm tra theo giá trị mong đợi [dễ bị lỗi do các tấm nhấp nháy bật và tắt, có khả năng xảy ra âm tính giả], hoặc. Tôi chỉ có thể mạnh mẽ vượt qua bằng cách nhấp vào từng vị trí tấm cứ sau vài giây. Trên thực tế, điều này hoàn toàn hiệu quả như giải pháp 'thanh lịch' là để bot xác định trạng thái của khách hàng. Nhấp vào sáu vị trí chỉ mất một phần giây trong khi việc lấy và xử lý sáu hình ảnh khác nhau tương đối chậm. Chúng ta có thể sử dụng thời gian tiết kiệm được cho các tác vụ xử lý hình ảnh quan trọng khác
Bước 17. Nhập Numpy và ImageOps
Thêm phần sau vào danh sách các báo cáo nhập khẩu của bạn
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']4
ImageOps là một mô-đun PIL khác. Nó được sử dụng để thực hiện các thao tác [chẳng hạn như thang độ xám] trên Hình ảnh
Tôi sẽ giải thích ngắn gọn phần thứ hai cho những người không quen thuộc với Python. Các câu lệnh nhập tiêu chuẩn của chúng tôi tải không gian tên của mô-đun [tập hợp các tên và hàm biến]. Vì vậy, để truy cập các mục trong phạm vi của mô-đun, chúng tôi phải sử dụng cú pháp
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]7. Tuy nhiên, bằng cách sử dụng câu lệnh
import ImageGrab import os import time66, chúng tôi kế thừa tên vào phạm vi cục bộ của mình. Có nghĩa là, cú pháp
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]7 không còn cần thiết nữa. Chúng không phải là cấp cao nhất, vì vậy chúng tôi sử dụng chúng như bất kỳ chức năng tích hợp sẵn nào khác của Python, như
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]03 hoặc
import ImageGrab import os import time69. Bằng cách nhập Numpy theo cách này, nó cho phép chúng tôi chỉ cần gọi
import ImageGrab import os import time70, thay vì
import ImageGrab import os import time71
Ký tự đại diện
import ImageGrab import os import time72 có nghĩa là nhập mọi thứ từ mô-đun
Bước 18. Làm cho máy tính nhìn thấy
Phương pháp đầu tiên chúng ta sẽ khám phá là kiểm tra giá trị RGB cụ thể của pixel so với giá trị dự kiến. Phương pháp này tốt cho những thứ tĩnh như menu. Vì nó xử lý các pixel cụ thể nên nó thường hơi mỏng manh đối với các đối tượng chuyển động. tuy nhiên, nó thay đổi theo từng trường hợp. Đôi khi đó là kỹ thuật hoàn hảo, lúc khác bạn sẽ phải sắp xếp một phương pháp khác
Mở Sushi Go Round trong trình duyệt của bạn và bắt đầu một trò chơi mới. Bỏ qua khách hàng của bạn và mở menu điện thoại. Bạn bắt đầu mà không có tiền trong ngân hàng, vì vậy mọi thứ sẽ chuyển sang màu xám như bên dưới. Đây sẽ là các giá trị RGB mà chúng tôi sẽ kiểm tra
Trong
import ImageGrab import os import time12, cuộn đến chức năng
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]8 của bạn. Chúng tôi sẽ thực hiện những thay đổi sau
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']5
Chúng tôi đã thực hiện hai thay đổi nhỏ. Trong dòng 5, chúng tôi đã nhận xét câu lệnh lưu của mình. Ở dòng 6, bây giờ chúng ta trả về đối tượng
import ImageGrab import os import time75 để sử dụng bên ngoài hàm
Lưu và chạy mã. Chúng tôi sẽ làm một số công việc tương tác hơn
Với menu Toppings đang mở và tất cả các mục chuyển sang màu xám, hãy chạy đoạn mã sau
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']6
Điều này chỉ định ảnh chụp nhanh mà chúng tôi chụp trong
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]8 cho ví dụ
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]02. Ở đây, chúng ta có thể gọi phương thức
import ImageGrab import os import time78 để lấy dữ liệu pixel cụ thể
Bây giờ chúng ta cần lấy các giá trị RGB cho từng mục bị mờ đi. Những giá trị này sẽ tạo nên 'giá trị kỳ vọng' của chúng tôi mà bot sẽ kiểm tra khi nó thực hiện cuộc gọi
import ImageGrab import os import time79 của riêng mình
Chúng tôi đã có tọa độ mà chúng tôi cần từ các bước trước, vì vậy tất cả những gì chúng tôi phải làm là chuyển chúng dưới dạng đối số cho
import ImageGrab import os import time79 và lưu ý đầu ra
get_phone_rgb
Đầu ra từ phiên tương tác của chúng tôi
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']7
Chúng ta cần thêm các giá trị này vào hàm
import ImageGrab import os import time81 của mình theo cách cho phép nó biết liệu có thứ gì đó khả dụng hay không
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']8
Ở đây chúng tôi chuyển tên thành phần cho hàm
import ImageGrab import os import time81. Một loạt câu lệnh if/elif được sử dụng để bắt tham số đã truyền và phản hồi tương ứng. Mỗi fork tuân theo cùng một logic, vì vậy chúng ta sẽ chỉ khám phá cái đầu tiên
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']9
Điều đầu tiên chúng tôi làm sau ngã ba
import ImageGrab import os import time83 là nhấp vào điện thoại và mở mục menu thích hợp - trong trường hợp này là menu Rice
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]90
Tiếp theo, chúng tôi chụp nhanh khu vực màn hình và gọi
import ImageGrab import os import time79 để lấy giá trị RGB cho pixel tại tọa độ của
import ImageGrab import os import time85. Sau đó, chúng tôi kiểm tra giá trị này dựa trên giá trị RGB đã thiết lập trước đó của chúng tôi khi mục bị mờ đi. Nếu nó đánh giá là
import ImageGrab import os import time86, chúng tôi biết rằng mặt hàng đó không còn bị mờ đi nữa và chúng tôi có đủ tiền để mua nó. Do đó, nếu nó được đánh giá là
import ImageGrab import os import time87, chúng tôi không đủ khả năng
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]91
Với điều kiện chúng tôi có đủ khả năng mua nguyên liệu, chúng tôi chỉ cần điều hướng qua các ô còn lại cần thiết để mua thực phẩm
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]92
Cuối cùng, nếu chúng tôi không đủ tiền mua thức ăn, chúng tôi yêu cầu Python đóng menu, đợi một giây rồi thử lại quy trình. Thường chỉ trong vài giây giữa việc có thể mua được thứ gì đó và không thể mua được thứ gì đó. Chúng tôi sẽ không làm điều đó trong hướng dẫn này, nhưng khá đơn giản để thêm logic bổ sung vào chức năng này để bot quyết định xem nó có cần tiếp tục đợi cho đến khi nó có đủ khả năng chi trả hay không hoặc nó có thể tự do thực hiện các nhiệm vụ khác và quay lại lúc
Bước 19. Theo dõi các thành phần
Được rồi, bây giờ chúng ta sẽ dần dần, từng chút một, bắt đầu thay thế các khu vực mà chúng ta, thực thể bên ngoài, cung cấp thông tin đầu vào và đưa ra quyết định bằng logic có thể tự vận hành
Chúng tôi cần thiết bị một cách để theo dõi xem chúng tôi hiện có bao nhiêu nguyên liệu. Chúng ta có thể làm điều này bằng cách ping màn hình ở một số khu vực nhất định hoặc bằng cách lấy trung bình mỗi hộp nguyên liệu [chúng ta sẽ nói về kỹ thuật này sau], nhưng cho đến nay, phương pháp đơn giản và nhanh nhất là cất giữ tất cả các vật phẩm có sẵn trong một hộp đựng.
Số lượng của mỗi thành phần không đổi trong mỗi cấp độ. Bạn sẽ luôn bắt đầu với 10 món 'thông thường' [gạo, nori, trứng cá] và 5 món 'cao cấp' [tôm, cá hồi, unagi]
Hãy thêm thông tin này vào từ điển
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]93
Các khóa từ điển của chúng tôi giữ tên của thành phần và chúng tôi sẽ có thể nhận được số lượng hiện tại bằng cách khám phá các giá trị
Bước 20. Thêm theo dõi vào mã
Bây giờ chúng ta đã có từ điển giá trị. Hãy đưa nó vào mã. Mỗi khi chúng tôi làm một cái gì đó, chúng tôi sẽ trừ các thành phần được sử dụng. Mỗi khi chúng tôi mua sắm, chúng tôi sẽ thêm lại chúng vào
Hãy bắt đầu bằng cách mở rộng hàm
import ImageGrab import os import time88
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]94
Giờ đây, mỗi khi chúng tôi làm một miếng Sushi, chúng tôi sẽ giảm các giá trị trong từ điển
import ImageGrab import os import time89 của mình xuống một lượng thích hợp. Tiếp theo, chúng tôi sẽ điều chỉnh buyFood[] để thêm giá trị
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]95
Giờ đây, mỗi khi một thành phần được mua, chúng tôi sẽ thêm số lượng vào giá trị từ điển thích hợp
Bước 21. Kiểm tra thực phẩm trên tay
Bây giờ chúng ta đã thiết lập các hàm
import ImageGrab import os import time88 và
import ImageGrab import os import time81 để sửa đổi từ điển
import ImageGrab import os import time89, chúng ta cần tạo một hàm mới để theo dõi tất cả các thay đổi và kiểm tra xem một thành phần có giảm xuống dưới một ngưỡng nhất định hay không
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]96
Ở đây, chúng tôi thiết lập một vòng lặp
import ImageGrab import os import time37 để lặp qua các cặp khóa và giá trị của từ điển
import ImageGrab import os import time89 của chúng tôi. Đối với mỗi giá trị, nó sẽ kiểm tra xem tên có bằng một trong những thành phần chúng ta cần hay không;
Hãy kiểm tra điều này một chút
check_food
Mọi thứ dường như đang hoạt động khá tốt, vì vậy hãy chuyển sang một số tác vụ nhận dạng hình ảnh khác
Bước 22. Di chuyển các giá trị RGB - Thiết lập
Để tiến xa hơn với bot của chúng tôi, chúng tôi cần thu thập thông tin về loại sushi nào có trong bong bóng của khách hàng. Làm điều này với phương pháp
import ImageGrab import os import time79 sẽ rất khó khăn vì bạn sẽ cần tìm một khu vực trong mỗi bong bóng suy nghĩ có giá trị RGB duy nhất không được chia sẻ bởi bất kỳ bong bóng suy nghĩ/loại sushi nào khác. Với nghệ thuật theo phong cách pixel, về bản chất, nó có một bảng màu hạn chế, bạn sẽ phải chiến đấu với hàng tấn màu trùng lặp trong các loại sushi. Ngoài ra, đối với mỗi loại sushi mới được giới thiệu trong trò chơi, bạn sẽ phải kiểm tra thủ công để xem liệu nó có RGB duy nhất không tìm thấy ở bất kỳ loại sushi nào khác hay không. Sau khi được tìm thấy, nó chắc chắn sẽ ở một tọa độ khác với các tọa độ khác, điều đó có nghĩa là lưu trữ nhiều giá trị tọa độ hơn - 8 loại sushi trên mỗi bong bóng nhân với 6 vị trí chỗ ngồi có nghĩa là 48 tọa độ cần thiết duy nhất
Tóm lại, chúng ta cần một phương pháp tốt hơn
Nhập phương pháp hai. Hình ảnh tổng hợp/trung bình. Phiên bản này hoạt động ngoài danh sách các giá trị RGB thay vì một pixel cụ thể. Đối với mỗi ảnh chụp nhanh chúng tôi chụp, hình ảnh được chia tỷ lệ xám, được tải vào một mảng và sau đó được tính tổng. Tổng này được xử lý giống như giá trị RGB trong phương pháp
import ImageGrab import os import time79. Chúng tôi sẽ sử dụng nó để kiểm tra và so sánh nhiều hình ảnh
Tính linh hoạt của phương pháp này đến mức một khi nó được thiết lập, trong trường hợp bot sushi của chúng tôi, chúng tôi không cần thực hiện thêm công việc nào nữa. Khi các loại sushi mới được giới thiệu, các giá trị RGB độc đáo của chúng được tổng hợp và in ra màn hình để chúng ta sử dụng. Không cần phải truy tìm thêm bất kỳ tọa độ cụ thể nào như với
import ImageGrab import os import time79
Điều đó nói rằng, vẫn còn một chút thiết lập cần thiết cho kỹ thuật này. Chúng tôi sẽ cần tạo một vài hộp giới hạn mới để chúng tôi chỉ xử lý khu vực màn hình mà chúng tôi cần chứ không phải toàn bộ khu vực chơi
Hãy bắt đầu. Điều hướng đến chức năng
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]8 của bạn và tạo một bản sao thứ hai của nó. Đổi tên bản sao thành
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']00 và thực hiện các thay đổi sau
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]97
Dòng 2. Chúng tôi đang chụp ảnh màn hình giống như chúng tôi đã làm trước đây, nhưng bây giờ chúng tôi đang chuyển đổi nó thành thang độ xám trước khi chúng tôi gán nó cho thể hiện _________ 102. Chuyển đổi sang thang độ xám giúp duyệt qua tất cả các giá trị màu nhanh hơn nhiều;
dòng 3. Chúng tôi tạo một mảng các giá trị màu của hình ảnh bằng phương thức PIL
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']02 và gán chúng cho biến
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']03
Dòng 4. Chúng tôi tính tổng tất cả các giá trị của mảng và in chúng ra màn hình. Đây là những con số chúng tôi sẽ sử dụng khi so sánh hai hình ảnh
Bước 23. Đặt hộp giới hạn mới
Bắt đầu một trò chơi mới và đợi tất cả khách hàng lấp đầy. Nhấp đúp chuột vào
import ImageGrab import os import time def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]26 để chụp nhanh khu vui chơi
Chúng ta sẽ cần đặt các hộp giới hạn bên trong mỗi bong bóng đó
Phóng to cho đến khi bạn có thể thấy chi tiết nhỏ của các điểm ảnh
Đối với mỗi bong bóng, chúng tôi cần đảm bảo phía trên bên trái của hộp giới hạn của chúng tôi bắt đầu ở cùng một vị trí. Để làm như vậy, hãy đếm hai 'cạnh' từ phía trong bên trái của bong bóng. Chúng tôi muốn pixel trắng ở 'cạnh' thứ hai đánh dấu vị trí x, y đầu tiên của chúng tôi
Để có được cặp dưới cùng, hãy thêm 63 vào vị trí x và 16 vào vị trí y. Điều này sẽ cung cấp cho bạn một hộp tương tự như bên dưới
Đừng lo lắng rằng chúng tôi không có được bức tranh toàn cảnh về loại Sushi. Vì chúng tôi đang tính tổng tất cả các giá trị nên ngay cả một thay đổi nhỏ trong một pixel cũng sẽ thay đổi tổng số và cho chúng tôi biết có gì đó mới trên màn hình
Chúng ta sẽ tạo sáu hàm mới, mỗi hàm là một phiên bản chuyên biệt của hàm chung
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']00 của chúng ta và điền vào các đối số giới hạn của chúng bằng tọa độ của tất cả các bong bóng. Khi chúng được tạo xong, chúng tôi sẽ tạo một chức năng đơn giản để gọi mọi thứ cùng một lúc, chỉ dành cho mục đích thử nghiệm
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]98
Được chứ. Rất nhiều mã, nhưng tất cả chỉ là phiên bản chuyên biệt của các chức năng đã xác định trước đó. Mỗi người xác định một hộp giới hạn và chuyển nó tới
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']06. Từ đó, chúng tôi chuyển đổi thành một mảng các giá trị RGB và in tổng ra màn hình
Hãy tiếp tục và chạy điều này một vài lần trong khi chơi trò chơi. Đảm bảo xác minh rằng mọi loại sushi, bất kể nó ở trong bong bóng nào, đều hiển thị cùng một số tiền mỗi lần
Bước 24. Tạo từ điển các loại Sushi
Khi bạn đã xác minh rằng mỗi loại sushi luôn hiển thị cùng một giá trị, hãy ghi lại tổng của chúng vào từ điển như sau
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]99
Có các số làm khóa và các chuỗi làm giá trị sẽ giúp dễ dàng xáo trộn mọi thứ từ chức năng này sang chức năng khác mà không mất dấu vết của mọi thứ
Bước 25. Tạo một lớp học không có bong bóng
Bước cuối cùng trong quá trình thu thập bong bóng của chúng tôi là nhận số tiền khi không có bong bóng nào. Chúng tôi sẽ sử dụng những thông tin này để kiểm tra thời điểm khách hàng đến và đi
Bắt đầu một trò chơi mới và nhanh chóng chạy
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']07 trước khi bất kỳ ai có cơ hội xuất hiện. Những con số nó in ra chúng ta sẽ đặt vào một lớp có tên là
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']08. Như trước đây, bạn có thể sử dụng từ điển nếu muốn
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]0
Bây giờ chúng tôi gần như ở đó. Một bước cuối cùng và chúng ta sẽ có một bot đơn giản, đang hoạt động
Bước 26. Để tất cả chúng cùng nhau
Cuối cùng đã đến lúc trao quyền kiểm soát cho bot của chúng tôi. Chúng tôi sẽ viết kịch bản theo logic cơ bản để cho phép nó phản hồi khách hàng, thực hiện đơn đặt hàng của họ và bổ sung các thành phần của nó khi bắt đầu cạn kiệt
Luồng cơ bản sẽ tuân theo điều này. Kiểm tra chỗ ngồi > nếu có khách, gọi món > kiểm tra đồ ăn > nếu ít, mua đồ ăn > dọn bàn > lặp lại
Đây là một con đường dài;
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]1
Điều đầu tiên chúng tôi làm là kiểm tra thực phẩm trên tay. từ đó, chúng tôi chụp nhanh vị trí một và gán tổng cho
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']09. Sau đó, chúng tôi kiểm tra xem
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']09 KHÔNG bằng
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']11. Nếu không, chúng tôi có một khách hàng. Chúng tôi kiểm tra từ điển
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']12 của chúng tôi để xem nó có tổng bằng với
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']09 của chúng tôi. Nếu đúng như vậy, thì chúng tôi gọi
import ImageGrab import os import time88 và chuyển
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']15 làm đối số
def screenGrab[]: box = [] im = ImageGrab.grab[] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG']16 được gọi cứ sau hai ghế
Chỉ còn một mảnh ghép cuối cùng. thiết lập vòng lặp
Bước 27. Vòng lặp chính
Chúng ta sẽ thiết lập một vòng lặp while rất đơn giản để chơi trò chơi. Chúng tôi không tạo ra bất kỳ loại cơ chế ngắt nào, vì vậy để dừng thực thi, hãy nhấp vào trình bao và nhấn Ctrl+C để gửi lệnh ngắt bàn phím
import ImageGrab import os import time def screenGrab[]: box = [157,346,796,825] im = ImageGrab.grab[box] im.save[os.getcwd[] + '\\full_snap__' + str[int[time.time[]]] + '.png', 'PNG'] def main[]: screenGrab[] if __name__ == '__main__': main[]2
Và đó là nó. Làm mới trang, tải trò chơi và giải phóng bot của bạn
Cuối cùng
Vì vậy, nó hơi cồng kềnh và cần được tinh chỉnh, nhưng nó là một khung xương tốt để bạn lặp đi lặp lại
Một phiên bản hoàn chỉnh hơn của bot có thể được tìm thấy ở đây. Nó có một số bản sửa lỗi như theo dõi những gì đang được thực hiện, không bị kẹt trong menu điện thoại và các tối ưu hóa chung khác
Sự kết luận
Giờ đây, bạn đã có tất cả các công cụ cần thiết để xây dựng các bot đơn giản của riêng mình. Các kỹ thuật chúng tôi sử dụng trong hướng dẫn này còn khá sơ khai trong thế giới Thị giác máy tính, tuy nhiên, nếu đủ kiên trì, bạn có thể tạo ra nhiều thứ thú vị với chúng - ngay cả bên ngoài lĩnh vực bot trò chơi. Ví dụ: chúng tôi chạy một số tập lệnh dựa trên các kỹ thuật này để tự động hóa các tác vụ phần mềm lặp đi lặp lại trong văn phòng. Thật là thỏa mãn khi loại bỏ một nhiệm vụ của con người chỉ bằng một vài dòng mã
Cảm ơn bạn đã đọc và nếu bạn có bất kỳ vấn đề hoặc nhận xét nào, hãy nhớ để lại ghi chú bên dưới. Chúc may mắn vui vẻ
Học Python
Tìm hiểu Python với hướng dẫn hướng dẫn đầy đủ về python của chúng tôi, cho dù bạn mới bắt đầu hay bạn là một lập trình viên dày dặn đang muốn học các kỹ năng mới