├── .eslintrc.js
├── .github
└── FUNDING.yml
├── .gitignore
├── .prettierignore
├── LICENSE
├── README.md
├── app
├── bot
│ ├── createBot.js
│ ├── createBots.js
│ ├── fishingZone.js
│ ├── lootExitZone.js
│ ├── lootZone.js
│ ├── notificationZone.js
│ ├── redButtonZone.js
│ ├── runBot.js
│ └── stats.js
├── config
│ ├── bot.json
│ ├── defaults.json
│ └── settings.json
├── game
│ ├── createGame.js
│ ├── nut.js
│ └── winSwitch.js
├── img
│ ├── add.png
│ ├── fish.png
│ ├── fold.png
│ ├── grass.png
│ ├── grate.png
│ ├── hint.png
│ ├── icon-premium.ico
│ ├── icon.ico
│ ├── icon.png
│ ├── install.gif
│ ├── lock.png
│ ├── logo.png
│ ├── premium.png
│ ├── remove.png
│ ├── start.png
│ ├── stop.png
│ ├── unfold.png
│ └── youtube_icon.png
├── index.html
├── main.js
├── renderer.js
├── style.css
├── ui
│ ├── autoFish.js
│ ├── renderSettings.js
│ ├── settings.js
│ ├── startButton.js
│ └── utils
│ │ ├── elt.js
│ │ └── wrapInLabel.js
├── utils
│ ├── eventLine.js
│ ├── fishingQuotes.json
│ ├── generateName.js
│ ├── getBitmap.js
│ ├── handleSquirrel.js
│ ├── keySupport.js
│ ├── logger.js
│ ├── rgb.js
│ ├── tests
│ │ ├── vec.test.js
│ │ └── zone.test.js
│ ├── textReader.js
│ ├── time.js
│ ├── vec.js
│ └── zone.js
└── wins
│ ├── advsettings
│ ├── img
│ │ ├── hint.png
│ │ └── icon.png
│ ├── index.html
│ ├── main.js
│ └── renderer.js
│ └── fishingzone
│ ├── chat.html
│ ├── fishing.html
│ ├── img
│ ├── bad.png
│ ├── cancel.png
│ ├── good.png
│ ├── icon.png
│ └── ok.png
│ ├── main.js
│ ├── rendererChat.js
│ ├── rendererFishing.js
│ └── style.css
├── guide_img
├── Premium_UI.jpg
├── UI.jpg
├── additionalactions.jpg
├── advancedSettings.jpg
├── aiResponse.jpg
├── arduino.jpg
├── chooseFishKey.jpg
├── chooseFishZone.jpg
├── chooseGame.jpg
├── icons
│ ├── bad.png
│ ├── good.png
│ └── question.png
├── intkey.jpg
├── lures.jpg
├── mammoth.jpg
├── motiondetection.jpg
├── rngMove.jpg
├── sound-detection.jpg
├── streaming.jpg
├── tmmenu.jpg
└── tmtoken.jpg
├── package.json
└── prettierrc.json
/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | "env": {
3 | "browser": true,
4 | "commonjs": true,
5 | "es2021": true
6 | },
7 | "globals": {
8 | "__dirname": "readonly",
9 | "process": "readonly",
10 | "_": "readonly"
11 | },
12 | "extends": "eslint:recommended",
13 | "overrides": [
14 | {
15 | "env": {
16 | "node": true
17 | },
18 | "files": [
19 | ".eslintrc.{js,cjs}"
20 | ],
21 | "parserOptions": {
22 | "sourceType": "script"
23 | }
24 | }
25 | ],
26 | "parserOptions": {
27 | "ecmaVersion": "latest"
28 | },
29 | "ignorePatterns": ["node_modules/", "out/", "img/", "tests/", "**/*.json", "**/*.html", "**/*.css"],
30 | "rules": {
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 |
3 | github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
4 | patreon: # Replace with a single Patreon username
5 | open_collective: # Replace with a single Open Collective username
6 | ko_fi: #
7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
13 | custom: buymeacoffee.com/jsbots
14 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | package-lock.json
2 | forge.config.js
3 | random.js
4 | cache/
5 | eng.traineddata
6 | # Logs
7 | logs
8 | *.log
9 | npm-debug.log*
10 | yarn-debug.log*
11 | yarn-error.log*
12 | lerna-debug.log*
13 | .pnpm-debug.log*
14 |
15 | # Diagnostic reports (https://nodejs.org/api/report.html)
16 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
17 |
18 | # Runtime data
19 | pids
20 | *.pid
21 | *.seed
22 | *.pid.lock
23 |
24 | # Directory for instrumented libs generated by jscoverage/JSCover
25 | lib-cov
26 |
27 | # Coverage directory used by tools like istanbul
28 | coverage
29 | *.lcov
30 |
31 | # nyc test coverage
32 | .nyc_output
33 |
34 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
35 | .grunt
36 |
37 | # Bower dependency directory (https://bower.io/)
38 | bower_components
39 |
40 | # node-waf configuration
41 | .lock-wscript
42 |
43 | # Compiled binary addons (https://nodejs.org/api/addons.html)
44 | build/Release
45 |
46 | # Dependency directories
47 | node_modules/
48 | jspm_packages/
49 |
50 | # Snowpack dependency directory (https://snowpack.dev/)
51 | web_modules/
52 |
53 | # TypeScript cache
54 | *.tsbuildinfo
55 |
56 | # Optional npm cache directory
57 | .npm
58 |
59 | # Optional eslint cache
60 | .eslintcache
61 |
62 | # Microbundle cache
63 | .rpt2_cache/
64 | .rts2_cache_cjs/
65 | .rts2_cache_es/
66 | .rts2_cache_umd/
67 |
68 | # Optional REPL history
69 | .node_repl_history
70 |
71 | # Output of 'npm pack'
72 | *.tgz
73 |
74 | # Yarn Integrity file
75 | .yarn-integrity
76 |
77 | # dotenv environment variables file
78 | .env
79 | .env.test
80 | .env.production
81 |
82 | # parcel-bundler cache (https://parceljs.org/)
83 | .cache
84 | .parcel-cache
85 |
86 | # Next.js build output
87 | .next
88 | out
89 |
90 | # Nuxt.js build / generate output
91 | .nuxt
92 | dist
93 |
94 | # Gatsby files
95 | .cache/
96 | # Comment in the public line in if your project uses Gatsby and not Next.js
97 | # https://nextjs.org/blog/next-9-1#public-directory-support
98 | # public
99 |
100 | # vuepress build output
101 | .vuepress/dist
102 |
103 | # Serverless directories
104 | .serverless/
105 |
106 | # FuseBox cache
107 | .fusebox/
108 |
109 | # DynamoDB Local files
110 | .dynamodb/
111 |
112 | # TernJS port file
113 | .tern-port
114 |
115 | # Stores VSCode versions used for testing VSCode extensions
116 | .vscode-test
117 |
118 | # yarn v2
119 | .yarn/cache
120 | .yarn/unplugged
121 | .yarn/build-state.yml
122 | .yarn/install-state.gz
123 | .pnp.*
124 |
--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
1 | package-lock.json
2 | forge.config.js
3 | random.js
4 | eng.traineddata
5 | # Logs
6 | logs
7 | *.log
8 | npm-debug.log*
9 | yarn-debug.log*
10 | yarn-error.log*
11 | lerna-debug.log*
12 | .pnpm-debug.log*
13 |
14 | # Diagnostic reports (https://nodejs.org/api/report.html)
15 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
16 |
17 | # Runtime data
18 | pids
19 | *.pid
20 | *.seed
21 | *.pid.lock
22 |
23 | # Directory for instrumented libs generated by jscoverage/JSCover
24 | lib-cov
25 |
26 | # Coverage directory used by tools like istanbul
27 | coverage
28 | *.lcov
29 |
30 | # nyc test coverage
31 | .nyc_output
32 |
33 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
34 | .grunt
35 |
36 | # Bower dependency directory (https://bower.io/)
37 | bower_components
38 |
39 | # node-waf configuration
40 | .lock-wscript
41 |
42 | # Compiled binary addons (https://nodejs.org/api/addons.html)
43 | build/Release
44 |
45 | # Dependency directories
46 | node_modules/
47 | jspm_packages/
48 |
49 | # Snowpack dependency directory (https://snowpack.dev/)
50 | web_modules/
51 |
52 | # TypeScript cache
53 | *.tsbuildinfo
54 |
55 | # Optional npm cache directory
56 | .npm
57 |
58 | # Optional eslint cache
59 | .eslintcache
60 |
61 | # Microbundle cache
62 | .rpt2_cache/
63 | .rts2_cache_cjs/
64 | .rts2_cache_es/
65 | .rts2_cache_umd/
66 |
67 | # Optional REPL history
68 | .node_repl_history
69 |
70 | # Output of 'npm pack'
71 | *.tgz
72 |
73 | # Yarn Integrity file
74 | .yarn-integrity
75 |
76 | # dotenv environment variables file
77 | .env
78 | .env.test
79 | .env.production
80 |
81 | # parcel-bundler cache (https://parceljs.org/)
82 | .cache
83 | .parcel-cache
84 |
85 | # Next.js build output
86 | .next
87 | out
88 |
89 | # Nuxt.js build / generate output
90 | .nuxt
91 | dist
92 |
93 | # Gatsby files
94 | .cache/
95 | # Comment in the public line in if your project uses Gatsby and not Next.js
96 | # https://nextjs.org/blog/next-9-1#public-directory-support
97 | # public
98 |
99 | # vuepress build output
100 | .vuepress/dist
101 |
102 | # Serverless directories
103 | .serverless/
104 |
105 | # FuseBox cache
106 | .fusebox/
107 |
108 | # DynamoDB Local files
109 | .dynamodb/
110 |
111 | # TernJS port file
112 | .tern-port
113 |
114 | # Stores VSCode versions used for testing VSCode extensions
115 | .vscode-test
116 |
117 | # yarn v2
118 | .yarn/cache
119 | .yarn/unplugged
120 | .yarn/build-state.yml
121 | .yarn/install-state.gz
122 | .pnp.*
123 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2023 jsbots
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
42 |
44 |
45 | For video review you can watch this (pretty old)
65 |
67 |
68 | 3. Set up your **Fishing Zone** by clicking the **Set Fishing Zone** button. Adjust the size and position of the **Fishing Zone** window to exclude any reddish or bluish elements (depending on the color you selected). Keep in mind that **Fishing Zone** is an overlay window, so it will also recognize colors from your character and the game's user interface, including texts and health bars.
69 |
70 |
71 |
73 |
74 | 4. Set up your **Fishing Key** by clicking on Fishing Key section and then pressing the key you want to bind. Your Fishing Key is the same key you bind your fishing skill to in the game.
75 |
76 |
77 |
79 |
80 | 5. You can press **Advanced Settings** and find there a lot of useful features and options.
81 |
82 |
83 |
85 |
86 | 6. Press the Start button and don't use your mouse and keyboard.
87 | 7. To stop the bot, press your designated stop key (default: delete).
88 |
89 | ### Hints and Issues
90 |
91 | - Avoid aggro mobs (with red names) in the Fishing Zone, if you use red color. Or turn them off in the settings (Interface -> Names -> NPC Names -> None)
92 | - If the bot can't find the bobber, try from the 1st person view.
93 | - If the bot doesn't react to animation, try from the 3rd person view.
94 | - The bot works only with default UI: no UI scaling, no UI addons and so on. (Especially ElvUI)
95 | - If the bot doesn't cast, though key is correct, launch it as admin.
96 | - The bot works only on a primary monitor.
97 | - Different camera directions can affect the brightness, size, and visibility of the bobber.
98 | - You can Adjust gamma, brightness, and contrast settings to enhance the brightness of the bobber.
99 | - The bot will auto-confirm lures application if such confirmation is needed.
100 | - The bot can auto-confirm *Soulbound* items. For that go to Advanced Settings and turn this option on.
101 | - If you use an addon that removes loot window (like Fishing Buddy), you can set *Loot Window Closing Delay* value to 0 to make it work faster.
102 | - The bot works at 50% efficiency on Turtle WoW and won't work better unless you use sound detection available in Premium.
103 | - Any features that print text will use English keyboard layout, so make sure you switched to English before using them.
104 |
105 | ### Intensity
106 |
107 | *If in manual mode*
108 |
109 | Intensity value serves as a color threshold below which the bot will ignore all the corresponding colors.
110 |
111 | Increasing the intensity value will make the bot recognize fewer red colors, while decreasing this value will cause the bot to recognize more red colors on the screen.
112 |
113 | Simply put: decrease this value, if the bot can't find the bobber (e.g. at night, bad weather). Increase this value if you want the bot to ignore some reddish/bluish elements in the Fishing Zone and recognize only the bobber.`
114 |
115 | ### Sensitivity
116 |
117 | *If in manual mode*
118 |
119 | If the bot clicks too early, decrease this value. If the bot clicks too late or doesn't click at all, increase this value.
120 |
121 | ### Interactive key
122 |
123 | You can fish with interactive key in the game. If you want the bot to use it instead of mouse movement, turn on Int. Key option and assign the same key you use for interactive key in the game.
124 |
125 |
126 |
128 |
129 | To make the interactive key work, you should use this commands (write them in the chat and press enter, one by one):
130 | ```
131 | /console SoftTargetInteractArc 2 - This will allow you to interact with the bobber no matter which way you are facing.
132 | /console SoftTargetInteractRange 30 - This increases the interaction range to 30 yards. Adjust to your needs
133 | ```
134 |
135 | ## Applying Lures :pushpin:
136 |
137 | Go to **Advanced Settings** and check **Use Lures**. Bind your key to the same key you bind your lures or **macro**.
138 |
139 |
140 |
142 |
143 | For **Retail** and **Classic/Vanilla** you need to use a special macro that will apply the lures onto your fishing pole. The names of the lures and fishing pole here only an example, you need to substitute them for your names:
144 |
145 | **Retail**:
146 |
147 | ```
148 | /use Aquadynamic Fish Attractor
149 | /use Big Iron Fishing Pole
150 | ```
151 |
152 | **Classic**:
153 |
154 | ```
155 | /equip Big Iron Fishing Pole
156 | /use Aquadynamic Fish Attractor
157 | /use 16
158 | /click StaticPopup1Button1
159 | ```
160 |
161 | **Vanilla**:
162 |
163 | ```
164 | /script UseAction(your lures key);
165 | /script PickupInventoryItem(16);
166 | /script ReplaceEnchant();
167 | ```
168 | Or
169 | ```
170 | /script UseContainerItem(0,2); PickupInventoryItem(16);
171 | ```
172 |
173 | ## AutoFish Premium :gem:
174 |
175 | AutoFish Premium is an updated version of the bot with many additional features.
176 |
177 |
178 |
180 |
181 | **Premium Features/Content:**
182 | - [Remote Control / Chat Detection](#remote-control--chat-detection-iphone)
183 | - [AI](#ai-speech_balloon)
184 | - [Multiple Fishing Mode](#multiple-fishing-mode-rocket)
185 | - [Alt-Tab Fishing Mode](#alt-tab-fishing-mode-sleeping)
186 | - [Sound Detection](#sound-detection-loud_sound)
187 | - [Additional Actions](#additional-actions-mage)
188 | - [Random camera/character movements](#random-cameracharacter-movements-robot)
189 | - [Hardware Control](#hardware-control-joystick)
190 | - [Streaming Mode](#streaming-mode-tv)
191 | - [Mount Selling](#mount-selling-elephant)
192 | - [Motion Detection](#motion-detection-runner)
193 | - [Check For Players Around](#check-for-players-around-telescope-unstable)
194 | - [Attacking / Running away](#attackingrunning-away-crossed_swords-unstable)
195 | - Profiles
196 |
197 | ## Remote Control / Chat Detection :iphone:
198 |
199 | You can control the bot via Telegram and it also can detect messages in your chat in the game and notify you.
200 |
201 | ### Guide:
202 |
203 | 1. Get the token from [BotFather](https://t.me/BotFather) by using /newbot command and following the instruction. Imagine some long and random name for the bot so that someone won't accidentally join your bot and gain control over your fishing process.
204 | 2. Paste the token to **Telegram token** input field in **Remote Control** section in the **Advanced Settings** and press enter.
205 |
206 |
207 |
209 |
210 | 3. Press **Connect** button and wait until the name of the button changes to either **done** or **error* (*might take awhile*).
211 | 4. Open the bot in your Telegram and either press /start or write /start command.
212 | 5. If everything is OK, the bot will reply with:
213 |
214 |
215 |
217 |
218 | 6. Create a separate tab in your chat and set its background to solid black for better visual detection, especially if you set the bot detect messages **by text**.
219 | 7. Now set your **Chat Zone** as on the screenshot below by pressing **Set Chat Zone** button on the main window of the AutoFish.
220 | 8. Start the bot from Telegram.
221 |
222 | Watch
227 |
229 |
230 | The bot can use one of **OpenRouter** AI models to generate a response to the messages it detects in the **Chat Zone** (it uses settings from **Remote Control** section).
231 |
232 | ### Guide:
233 |
234 | 1. Sign In to [OpenRouter](https://openrouter.ai/) and get an API key: *Profile -> Keys -> Create Key*.
235 | 2. Paste it into **API Key** field.
236 | 3. Choose a model from the list.
237 | 4. You can change **AI Prompt* field to your own context and test the result in **AI Test** section.
238 |
239 | ## Multiple Fishing Mode :rocket:
240 |
241 | In **Multiple Fishing** mode you can use the bot simultaneously with multiple game windows, the bot will switch between the windows and can work with up to 10 windows at the same time.
242 |
243 |
244 | **Guide(normal mode):**
245 | Ensure each window is properly launched and configured, and **every game instance is set to DirectX 11 or lower** *(older games doesn't need it)*.
246 |
247 | In this mode, the bot will use special profiles specific to each window: WIN1, WIN2, WIN3 and so on *(check in profiles list)*. Each "WIN" profile must have a **"Custom Window"** configured *(found under Advanced Settings -> Window)*. Use the **"Focus"** button to check which window you've selected.
248 |
249 | **Simple guide:** choose WIN1 in profiles above -> Go to Advanced Settings -> Custom Window -> Choose the window for the first game -> Repeat the same for every next window.
250 |
251 |
252 | Watch
285 |
287 |
288 | Sound Detection is an alternative to pixel recognition logic. The bot will hook the bobber only after "splash" sound and won't rely on checking the animation of the bobber plunging.
289 |
290 | Before using sound detection turn off Music and Ambient Sounds in the game, leave only Sound Effects. Try to find a place secluded from the sounds made by other players to avoid false detections.
291 |
292 | You can also use Alt-Tab Fishing Mode with Sound Detection, with Int.Key + Sound Detection the bot will focus the window only when it needs to cast and when it detects splash sound (turn on **Sound in Background** for that).
293 |
294 | Use **"Listen"** button to determine the amplitude of the splashing sound when your bobber plunges in the water: start fishing then press "Listen" button and check for "Max" value when the fish is caught. Do it couple of times to determine the stable value.
295 |
296 | If you want to make the bot listen only to the sounds of the game you can use [Virtual Audio Cable](https://vb-audio.com/Cable/) to "pipe" the sound from the game to an input device and then choose it in the settings of the bot. If your game doesn't support in-game choice for sound output device, you can manually set Output device for your game in **"App volume and device preferences"** settings of your Windows to **CABLE input (VB-Audio Virtual Cable)** and then choose **CABLE output (VB-Audio Virtual Cable)** in the settings of the bot.
297 |
298 | For Sound Detection to work in [Streaming Mode](#streaming-mode-tv), you need to stream sound as well. So add **Application Audio Capture (BETA)** source in addition to the video source in your OBS.
299 |
300 | Watch
305 |
307 |
308 | You can set a zone for motion detection and the bot will notifiy you via Telegram of any events happening in this zone/area. It will also send a screenshot of the motion occured. This feature might help against griefing.
309 |
310 | ## Additional Actions :mage:
311 |
312 |
313 |
315 |
316 | With Additional Actions module you can perform basically any automation you need during the fishing process. You can automate any mouse or keyboard movements as well as add some additional pixel conditions. It can be used for different things: applying additional lures, opening or deleting some items, automating sending caught fish in the process and so on.
317 |
318 | ## Mount Selling :elephant:
319 |
320 |
321 |
323 |
324 | As an alternative to filtering you can use a trader on your mammoth mount to sell all the junk items during the fishing. The bot will summon your mount, target your trader, interact with it by using interaction key in the game, unsummon the mount and go on fishing.
325 |
326 | Because of the novelty of the interaction key this feature is available only for Retail.
327 |
328 | Depends on the mount the name of your trader might be different, so change the default value.
329 |
330 | Watch
335 |
337 |
338 | The bot will randomly move and change your camera direction from time to time within the provided radius.
339 |
340 | Watch
345 |
347 |
348 | The bot is able to connect to your Arduino Board/Raspberry Pico W and use it to emulate a mouse/keyboard device, it will look like a real keyboard or mouse to the OS and the game. What you need to do to make it possible:
349 |
350 | 1. Get an Arduino with an ATmega32U4 on board (any cheap copies for 2-3$ will do too, you can find them on Chinese online markets).
351 | 2. Connect it to your computer.
352 | 3. Install [Arduino IDE](https://www.arduino.cc/en/software).
353 | 4. Click **New Sketch** and replace everything there with this sketch: [Arduino Sketch](https://github.com/jsbots/Clicker/blob/main/clicker_sketch/clicker_sketch.ino).
354 | 5. Click **Tools** -> **Port** and choose the port your Arduino Board connected to.
355 | 6. Click **Sketch** -> **Upload** and wait until the code uploads to your board.
356 | 7. Launch AutoFish, click **Advanced Settings** turn on **Use Arduino Board** option and choose the port your Arduino Board connected to, press **Connect** button.
357 |
358 | For **Raspberry Pico W** guide check [Streaming Mode](#streaming-mode-tv).
359 |
360 | Watch
365 |
367 |
368 | Streaming Mode is used to run the bot and the game on different computers, you can use either hardware device for capturing your screen or stream it with OBS to the MediaMTX Server provided by the bot *(recommended)*.
369 |
370 | In both cases you need a **Raspberry Pico W** device to simulate hardware input, how to configure and connect it you can find in this video:
468 |
470 |
471 | Check again [Disclaimer](#disclaimer-warning) before downloading or running any of these (*I'm serious, the bot has been there for 3 years and people are still doing stupid things with it. Don't launch/use it if you are new to this stuff.*):
472 |
473 | AutoFish 2.8.3: [Download](https://github.com/jsbots/AutoFish/releases/tag/v2.8.3)
474 |
475 | AutoFish 3.3.0 Premium (trial version): [Download](https://buymeacoffee.com/jsbots/e/258390)
476 |
477 | AutoFish 3.3.0 Premium: [Download](https://www.buymeacoffee.com/jsbots/e/96734)
478 |
--------------------------------------------------------------------------------
/app/bot/createBot.js:
--------------------------------------------------------------------------------
1 | const Zone = require("../utils/zone.js");
2 | const createFishingZone = require("./fishingZone.js");
3 | const createNotificationZone = require("./notificationZone.js");
4 | const createLootZone = require("./lootZone.js");
5 | const createLootExitZone = require("./lootExitZone.js");
6 | const createRedButtonZone = require("./redButtonZone.js");
7 | const {app} = require(`electron`);
8 | const Vec = require('../utils/vec.js');
9 | const nutMouse = require("../game/nut.js").mouse;
10 |
11 | const { screen, Region, Point } = require("@nut-tree/nut-js");
12 |
13 | let once = (fn, done) => (...args) => {
14 | if(!done) {
15 | done = true;
16 | return fn(...args);
17 | }
18 | }
19 |
20 | const {
21 | percentComparison,
22 | readTextFrom,
23 | sortWordsByItem,
24 | } = require("../utils/textReader.js");
25 |
26 | const { createTimer } = require("../utils/time.js");
27 |
28 | const sleep = (time) => {
29 | return new Promise((resolve) => {
30 | setTimeout(resolve, time);
31 | });
32 | };
33 |
34 | const random = (from, to) => {
35 | return from + Math.random() * (to - from);
36 | };
37 |
38 | const createBot = (game, { config, settings }, winSwitch, state) => {
39 | if(settings.game == `Vanilla (splash)` && settings.autoTh == true) {
40 | settings.autoTh = false;
41 | };
42 |
43 | const { keyboard, mouse, workwindow } = game;
44 | const delay = [config.delay.from, config.delay.to];
45 |
46 | const action = async (callback) => {
47 | if(state.status == `stop`) return;
48 |
49 | await winSwitch.execute(workwindow);
50 | await callback();
51 | winSwitch.finished();
52 | };
53 |
54 | const screenSize = workwindow.getView();
55 |
56 | const actionOnce = once(action);
57 |
58 | const missOnPurposeValue = config.missOnPurpose ? random(config.missOnPurposeRandom.from, config.missOnPurposeRandom.to) : 0;
59 | const getDataFrom = async (zone) => {
60 | if(zone.x < 0) zone.x = 0;
61 | if(zone.y < 0) zone.y = 0;
62 | if(zone.width > screenSize.width) zone.width = screenSize.width;
63 | if(zone.height > screenSize.height) zone.height = screenSize.height;
64 |
65 | switch(true) {
66 | case config.libraryType == 'nut.js': {
67 | await actionOnce(() => {});
68 | let grabbed = await(await screen.grabRegion(new Region(zone.x + screenSize.x, zone.y + screenSize.y, zone.width, zone.height))).toRGB();
69 | return grabbed;
70 | }
71 |
72 | case config.libraryType == 'keysender': {
73 | return workwindow.capture(zone);
74 | }
75 | }
76 | };
77 |
78 | let fishingZone = createFishingZone(getDataFrom, Zone.from(screenSize).toRel(config.relZone), screenSize, settings, config);
79 | const notificationZoneRel = Zone.from({
80 | x: Math.round((screenSize.width / 2) - (screenSize.width * config.notificationPos.width)),
81 | y: Math.round(screenSize.height * config.notificationPos.y),
82 | width: Math.round((screenSize.width * config.notificationPos.width) * 2),
83 | height: Math.round(screenSize.height * config.notificationPos.height)
84 | });
85 | const notificationZone = createNotificationZone({
86 | getDataFrom,
87 | zone: notificationZoneRel,
88 | });
89 |
90 | let lootWinResType;
91 | switch(true) {
92 | case screenSize.height <= 768: {
93 | lootWinResType = `1536`
94 | break;
95 | }
96 |
97 | case screenSize.height > 768 && screenSize.height <= 1080: {
98 | lootWinResType = `1920`;
99 | break;
100 | }
101 |
102 | case screenSize.height > 1080 && screenSize.height <= 1440: {
103 | lootWinResType = `2560`;
104 | break;
105 | }
106 |
107 | case screenSize.height > 1440: {
108 | lootWinResType = `3840`;
109 | }
110 | }
111 | let ultrawide = (screenSize.width / screenSize.height) > 2;
112 |
113 | const lootWindowPatch = config.lootWindow[lootWinResType] ? config.lootWindow[lootWinResType] : config.lootWindow[`1920`];
114 |
115 | const confirmationWindowPatch =
116 | config.confirmationWindow[screenSize.width <= 1536 ? `1536` : `1920`];
117 |
118 | let ignoreInterruptedPatch;
119 | if(config.ignoreInterrupted) {
120 | ignoreInterruptedPatch = config.ignoreInterrupted[screenSize.width <= 1536 ? `1536` : `1920`];
121 | }
122 |
123 | const lootWindow = {
124 | upperLimit: lootWindowPatch.upperLimit * screenSize.height,
125 | toItemX: lootWindowPatch.toItemX * (ultrawide ? Number(lootWinResType) : screenSize.width),
126 | toItemY: lootWindowPatch.toItemY * screenSize.height,
127 | width: lootWindowPatch.width * (ultrawide ? Number(lootWinResType) : screenSize.width),
128 | height: lootWindowPatch.height * screenSize.height,
129 | itemHeight: lootWindowPatch.itemHeight * screenSize.height,
130 | };
131 |
132 | if(lootWindowPatch.itemHeightAdd) {
133 | lootWindow.itemHeightAdd = lootWindowPatch.itemHeightAdd * screenSize.height;
134 | }
135 |
136 | const confirmationWindow = {
137 | x: (screenSize.width / 2) - (confirmationWindowPatch.x * screenSize.width),
138 | y: confirmationWindowPatch.y * screenSize.height,
139 | width: confirmationWindowPatch.width * screenSize.width,
140 | height: confirmationWindowPatch.height * screenSize.height
141 | };
142 |
143 | if(lootWindowPatch.cursorPos) {
144 | lootWindow.cursorPos = {
145 | x: lootWindowPatch.cursorPos.x * (ultrawide ? Number(lootWinResType) : screenSize.width),
146 | y: lootWindowPatch.cursorPos.y * screenSize.height
147 | }
148 | }
149 |
150 | if(lootWindowPatch.exitButton) {
151 | lootWindow.exitButton = {
152 | x: lootWindowPatch.exitButton.x * (ultrawide ? Number(lootWinResType) : screenSize.width),
153 | y: lootWindowPatch.exitButton.y * screenSize.height
154 | }
155 | }
156 |
157 | const lootExitZone = createLootExitZone({getDataFrom, lootWindow, size: 10 * (screenSize.width / 1920)});
158 |
159 | const whitelist = config.whitelistWords
160 | .split(",")
161 | .map((word) => word.trim());
162 |
163 |
164 | const generateMovePastPos = (pos) => {
165 | let posFromCurrent = {x: pos.x - mouse.getPos().x, y: pos.y - mouse.getPos().y};
166 | let movePastDir = {x: posFromCurrent.x > 0 ? 1 : -1, y: posFromCurrent.y > 0 ? 1 : -1};
167 | let movePastMaxMain = Math.abs(posFromCurrent.x) > Math.abs(posFromCurrent.y) ? "x" : "y";
168 | let movePastMaxSub = Math.abs(posFromCurrent.x) < Math.abs(posFromCurrent.y) ? "x" : "y";
169 |
170 | const movePastDist = Math.sqrt(Math.pow(Math.abs(posFromCurrent.x), 2) + Math.pow(Math.abs(posFromCurrent.y), 2)) * .5;
171 |
172 | posFromCurrent[movePastMaxMain] += (movePastDist * random(0.15, 0.20)) * movePastDir[movePastMaxMain];
173 | posFromCurrent[movePastMaxSub] += (movePastDist * random(0.05, 0.10)) * movePastDir[movePastMaxSub];
174 |
175 | return {x: posFromCurrent.x + mouse.getPos().x, y: posFromCurrent.y + mouse.getPos().y};
176 | }
177 |
178 | const moveTo = async ({ pos, randomRange, fineTune = {offset: randomRange || 5, steps: [1, 3]}, forcedNutMouse}) => {
179 | if (randomRange) {
180 | pos.x = pos.x + random(-randomRange, randomRange);
181 | pos.y = pos.y + random(-randomRange, randomRange);
182 | }
183 |
184 | if (config.likeHuman) {
185 | let convertedSpeed = config.mouseMoveSpeed / 100;
186 | let speedByRes = convertedSpeed * (screenSize.width / 1920);
187 | let speedCoofByRes = 0.15 * (screenSize.width / 1920);
188 | let randomSpeed = {from: speedByRes - speedCoofByRes, to: speedByRes + speedCoofByRes}
189 | if(randomSpeed.from < 0) {
190 | randomSpeed.from = 0;
191 | }
192 |
193 | let deviationCoof = config.libraryTypeInput === 'nut.js' ? 30 : 15;
194 | let randomDeviation = {from: config.mouseCurvatureStrength - deviationCoof, to: config.mouseCurvatureStrength + deviationCoof};
195 | if(randomDeviation.from < 0) {
196 | randomDeviation.from = 0;
197 | }
198 |
199 | if(config.libraryTypeInput === 'nut.js' || forcedNutMouse) {
200 | if(!(pos instanceof Vec)) {
201 | pos = new Vec(pos.x, pos.y);
202 | }
203 | let curPos = mouse.getPos();
204 | curPos = new Vec(curPos.x, curPos.y);
205 | await nutMouse.humanMoveTo({
206 | from: curPos.plus(screenSize),
207 | to: pos.plus(screenSize),
208 | speed: random(randomSpeed.from, randomSpeed.to),
209 | deviation: random(randomDeviation.from, randomDeviation.to),
210 | fishingZone: Zone.from(screenSize).toRel(config.relZone)
211 | });
212 | } else {
213 | await mouse.humanMoveTo(pos.x, pos.y, random(randomSpeed.from, randomSpeed.to), random(randomDeviation.from, randomDeviation.to));
214 | }
215 |
216 | if(config.likeHumanFineTune && fineTune && state.status != "stop") {
217 | let times = random(fineTune.steps[0], fineTune.steps[1]);
218 | for(let i = 1; i <= times; i++) {
219 | await mouse.humanMoveTo(
220 | pos.x + random(-fineTune.offset / i, fineTune.offset / i),
221 | pos.y + random(-fineTune.offset / i, fineTune.offset / i),
222 | random(randomSpeed.from / 3, randomSpeed.to / 3),
223 | random(randomDeviation.from, randomDeviation.to)
224 | );
225 | await sleep(random(25, 150));
226 | }
227 | }
228 | } else {
229 | await mouse.moveTo(pos.x, pos.y, delay);
230 | }
231 | };
232 |
233 | const checkRedButton = async (buttonPos) => {
234 | const redButtonZone = createRedButtonZone({getDataFrom, zone: buttonPos});
235 | const colorPositions = await redButtonZone.isOn(mouse.getPos());
236 | if(colorPositions){
237 | let colorPos = colorPositions.yellow || colorPositions.red;
238 | await action(async () => {
239 | await moveTo({pos: {
240 | x: buttonPos.x + colorPos.x,
241 | y: buttonPos.y + colorPos.y},
242 | randomRange: 2,
243 | });
244 | });
245 |
246 | return await redButtonZone.isOnAfterHighlight()
247 | }
248 | };
249 |
250 | const checkBobberTimer = createTimer(() => config.maxFishTime * 1000);
251 | const missOnPurposeTimer = createTimer(() => random(config.missOnPurposeRandomDelay.from, config.missOnPurposeRandomDelay.to) * 1000);
252 | const logOutTimer = createTimer(() => random(config.logOutEvery.from * 1000 * 60, config.logOutEvery.to * 1000 * 60));
253 |
254 | const logOut = async (state) => {
255 | await action(async () => {
256 | if(config.logOutUseMacro) {
257 | await keyboard.toggleKey(config.logOutMacroKey, true, delay);
258 | await keyboard.toggleKey(config.logOutMacroKey, false, delay);
259 | } else {
260 | await keyboard.toggleKey(`enter`, true, delay);
261 | await keyboard.toggleKey(`enter`, false, delay);
262 | await keyboard.printText(`/logout`, delay);
263 | await keyboard.toggleKey(`enter`, true, delay);
264 | await keyboard.toggleKey(`enter`, false, delay);
265 | }
266 | });
267 | await sleep(20000);
268 |
269 | const addTime = applyLures.timer.timeRemains();
270 |
271 | await sleep(random(config.logOutFor.from * 1000, config.logOutFor.to * 1000));
272 | if(state.status == 'stop') {
273 | return;
274 | }
275 | await action(async () => {
276 | await keyboard.sendKey(`enter`);
277 | });
278 | await sleep(random(config.logOutAfter.from * 1000, config.logOutAfter.from * 1000));
279 |
280 | if(config.lures) {
281 | applyLures.timer.update(() => addTime);
282 | }
283 |
284 | };
285 | logOut.timer = logOutTimer;
286 | logOut.on = config.logOut > 0;
287 |
288 |
289 | const preliminaryChecks = async (log) => {
290 | if(config.ignorePreliminary) return;
291 |
292 | if (screenSize.x == -32000 && screenSize.y == -32000) {
293 | throw new Error("The window is either in fullscreen mode or minimized. Switch to windowed or windowed(maximized).");
294 | }
295 |
296 | if(settings.autoColor) {
297 | let colorPercent = await fishingZone.checkColor();
298 | if(colorPercent > 25) {
299 | fishingZone.changeColor();
300 | }
301 | }
302 |
303 | if(!settings.autoTh) {
304 | let bobber = await fishingZone.findBobber(null, log);
305 | if (bobber) {
306 | screen.config.highlightOpacity = 1;
307 | screen.config.highlightDurationMs = 1000;
308 | const highlightRegion = new Region(screenSize.x + (bobber.x - 30), screenSize.y + (bobber.y - 30), 30, 30);
309 | await screen.highlight(highlightRegion);
310 |
311 | throw new Error(
312 | `Found ${settings.bobberColor == `red` ? `red` : `blue`} colors before casting. Change your Fishing Zone or increase the intensity value or change the fishing place.`
313 | );
314 | }
315 | }
316 | };
317 |
318 | const applyLures = async () => {
319 | await action(async () => {
320 | await keyboard.sendKey(config.luresKey, delay);
321 | });
322 |
323 | if(config.confirmLures) {
324 | if (config.reaction) {
325 | await sleep(random(config.reactionDelay.from, config.reactionDelay.to));
326 | } else {
327 | await sleep(250) // wait for the window to appear
328 | }
329 | const needsConfirm = await checkRedButton(confirmationWindow);
330 | if(needsConfirm) {
331 | await action(async () => {
332 | await mouse.toggle('left', true, delay);
333 | await mouse.toggle('left', false, delay);
334 | });
335 | }
336 | }
337 |
338 | await sleep(config.luresDelay);
339 | };
340 |
341 | applyLures.on = config.lures;
342 | applyLures.timer = createTimer(() => {
343 | return config.luresDelayMin * 60 * 1000;
344 | });
345 |
346 | if(config.luresOmitInitial) {
347 | applyLures.timer.start();
348 | }
349 |
350 | const randomSleep = async () => {
351 | let sleepFor = random(
352 | config.randomSleepDelay.from * 1000,
353 | config.randomSleepDelay.to * 1000
354 | );
355 | await sleep(sleepFor);
356 | };
357 |
358 | randomSleep.on = config.randomSleep;
359 | randomSleep.timer = createTimer(() => {
360 | return (
361 | random(config.randomSleepEvery.from, config.randomSleepEvery.to) *
362 | 60 *
363 | 1000
364 | );
365 | });
366 |
367 | const cutOutNotification = (zone) => {
368 | let noteZone = Zone.from(screenSize).toRel(zone);
369 | let fZone = Zone.from(screenSize).toRel(config.relZone)
370 | let result = [];
371 | for(let y = noteZone.y - fZone.y; y < (noteZone.y - fZone.y) + noteZone.height; y++) {
372 | for(let x = noteZone.x - fZone.x; x < (noteZone.x - fZone.x) + noteZone.width; x++) {
373 | result.push(new Vec(x, y));
374 | }
375 | }
376 | return result;
377 | }
378 |
379 | const findAllBobberColors = async () => {
380 | if(settings.game != `Retail` && settings.game != `Cata Classic` && settings.game != `Classic`) {
381 | let bobber = await fishingZone.getBobberPrint(10);
382 |
383 | if(!bobber) {
384 | return;
385 | }
386 |
387 | if(config.ignoreInterrupted) {
388 | let interruptedArea = cutOutNotification(ignoreInterruptedPatch);
389 | bobber = [...bobber, ...interruptedArea];
390 | }
391 |
392 | return bobber;
393 | } else {
394 | return null;
395 | }
396 | };
397 |
398 | const castFishing = async (state) => {
399 | await action(async () => {
400 | await keyboard.sendKey(settings.fishingKey, delay);
401 | });
402 |
403 | if (state.status == "initial") {
404 | await sleep(250);
405 | if (!config.ignorePreliminary && await notificationZone.check("error")) {
406 | throw new Error(`Game error notification occured on casting fishing.`);
407 | } else {
408 | state.status = "working";
409 | }
410 | }
411 |
412 | if(settings.checkLogic == `pixelmatch`) {
413 | await sleep(2500);
414 | } else {
415 | await sleep(random(config.castDelay, config.castDelay + 500));
416 | }
417 | };
418 |
419 | const highlightBobber = async (pos, log) => {
420 | if (settings.checkLogic == `pixelmatch` ||
421 | settings.useInt ||
422 | (config.likeHuman && random(0, 100) > config.highlightPercent)) {
423 | return pos;
424 | }
425 |
426 | if (config.reaction) {
427 | await sleep(random(config.reactionDelay.from, config.reactionDelay.to));
428 | }
429 |
430 | await action(async () => {
431 | if(config.likeHumanFineTune) {
432 | let pastPost = generateMovePastPos(pos);
433 | await moveTo({pos: pastPost, fineTune: null})
434 | }
435 |
436 | await moveTo({ pos, randomRange: 5, fineTune: {offset: 5, steps: [1, 5]}});
437 | });
438 |
439 | return await findBobber(log, pos);
440 | };
441 |
442 | const findBobber = async (log, highlight) => {
443 | const pos = await fishingZone.findBobber(findBobber.memory, log, highlight);
444 |
445 | if(pos && process.env.NODE_ENV == `dev`) {
446 | screen.config.highlightOpacity = 1;
447 | screen.config.highlightDurationMs = 250;
448 | const highlightRegion = new Region(screenSize.x + (pos.x - 5), screenSize.y + (pos.y - 5), 10, 10);
449 | await screen.highlight(highlightRegion);
450 | }
451 |
452 | return pos;
453 | };
454 | findBobber.memory = null;
455 | findBobber.maxAttempts = config.maxAttempts;
456 |
457 | const checkBobber = async (pos, state) => {
458 | checkBobberTimer.start();
459 | const startTime = Date.now();
460 | const missOnPurpose = random(0, 100) < missOnPurposeValue;
461 | if(missOnPurpose) {
462 | missOnPurposeTimer.update();
463 | }
464 |
465 | while (state.status == "working") {
466 | if (checkBobberTimer.isElapsed()) {
467 | switch(config.maxFishTimeAfter) {
468 | case `stop`: {
469 | throw new Error(
470 | `Something is wrong. The bot had been checking the bobber for more than ${config.maxFishTime} ms. The server might be down or your character is dead.`
471 | );
472 | }
473 | case `recast`: {
474 | state.status = `working`;
475 | return false;
476 | }
477 | }
478 | }
479 |
480 | if(missOnPurpose && missOnPurposeTimer.isElapsed()) {
481 | pos.missedIntentionally = true;
482 | return pos;
483 | }
484 |
485 | if(settings.checkLogic == `pixelmatch`) {
486 | if(await fishingZone.checkPixelMatch(pos, startTime)) {
487 | return pos;
488 | };
489 | } else if(settings.game == `Retail`) {
490 | if(!(await fishingZone.checkBobberPrint(pos))) {
491 | return pos;
492 | }
493 | } else if (settings.game == `Vanilla (splash)`) {
494 | if(await fishingZone.checkBobberPrintSplash(pos)) {
495 | return pos;
496 | }
497 | } else {
498 | if (!(await fishingZone.isBobber(pos))) {
499 | const newPos = settings.autoTh ? await fishingZone.checkBelow(pos) : await fishingZone.checkAroundBobber(pos);
500 | if (!newPos) {
501 | return pos;
502 | } else {
503 | pos = newPos;
504 | }
505 | }
506 |
507 | if(settings.autoTh) {
508 | pos = await fishingZone.checkAbove(pos);
509 | }
510 | }
511 | await sleep(config.checkingDelay);
512 | }
513 |
514 | };
515 |
516 | const pickLoot = async () => {
517 | let cursorPos = config.atMouse || !lootWindow.cursorPos ? mouse.getPos() : lootWindow.cursorPos;
518 | if (cursorPos.y - lootWindow.upperLimit < 0) {
519 | cursorPos.y = lootWindow.upperLimit;
520 | }
521 |
522 | if (config.reaction) {
523 | await sleep(random(config.reactionDelay.from, config.reactionDelay.to)); // react to opening loot win
524 | } else {
525 | await sleep(150); // open loot window
526 | }
527 |
528 | if(settings.game != `Retail`) {
529 | let pos = {
530 | x: cursorPos.x + random(-(lootWindow.width * .25), lootWindow.width * .25),
531 | y: cursorPos.y - lootWindow.toItemY - 10,
532 | };
533 | await moveTo({ pos, randomRange: 5 });
534 | }
535 |
536 | if (config.reaction) {
537 | await sleep(random(config.reactionDelay.from, config.reactionDelay.to)); // hint disappearing and smooth text analyzing time with random value
538 | } else {
539 | await sleep(150); // hint dissappearing
540 | }
541 |
542 | if(lootWindow.exitButton) {
543 | for(let times = 0; times <= 20; times++) { // Wait for 2 seconds max until loot appears
544 | await sleep(100);
545 | if(await lootExitZone.isLootOpened(cursorPos)) {
546 | break;
547 | }
548 |
549 | if(times == 20) {
550 | return [];
551 | }
552 | }
553 | }
554 |
555 | const lootWindowDim = {
556 | x: cursorPos.x + lootWindow.toItemX,
557 | y: cursorPos.y - lootWindow.toItemY,
558 | width: lootWindow.width,
559 | height: lootWindow.height,
560 | };
561 |
562 | let recognizedWords = await readTextFrom(await getDataFrom(lootWindowDim), screenSize.width <= 1536 ? 3 : 2);
563 | let items = sortWordsByItem(recognizedWords, lootWindow, settings.game == `Retail`);
564 | let itemPos = 0;
565 |
566 | let itemsPicked = [];
567 | for (let item of items) {
568 | let isInList = whitelist.find((word) => percentComparison(word, item) > 90);
569 |
570 | if(config.filterType == `blacklist`) {
571 | if(isInList) {
572 | isInList = false;
573 | } else {
574 | isInList = true;
575 | }
576 | }
577 |
578 | if (!isInList && config.whiteListBlueGreen) {
579 | let lootZone = createLootZone({
580 | getDataFrom,
581 | zone: {
582 | x: lootWindowDim.x,
583 | y: lootWindowDim.y + itemPos,
584 | width: lootWindow.width,
585 | height: lootWindow.itemHeight,
586 | },
587 | });
588 |
589 | isInList = await lootZone.findItems("blue", "green", "purple");
590 | }
591 |
592 | if (isInList) {
593 | await moveTo({
594 | pos: {
595 | x: cursorPos.x,
596 | y: cursorPos.y + itemPos,
597 | },
598 | randomRange: 5,
599 | });
600 |
601 | if (config.reaction && random(0, 10) > 8) { // sometimes we think
602 | await sleep(random(config.reactionDelay.from, config.reactionDelay.to));
603 | } else {
604 | await sleep(random(50, 150));
605 | }
606 |
607 | await mouse.toggle("right", true, delay);
608 | await mouse.toggle("right", false, delay);
609 |
610 | if(typeof isInList == `boolean` && config.confirmSoulbound) {
611 | if (config.reaction) {
612 | await sleep(random(config.reactionDelay.from, config.reactionDelay.to));
613 | } else {
614 | await sleep(250) // wait for the window to appear
615 | }
616 | const needsConfirm = await checkRedButton(confirmationWindow);
617 | if(needsConfirm) {
618 | await action(async () => {
619 | await mouse.toggle('left', true, delay);
620 | await mouse.toggle('left', false, delay);
621 | });
622 | }
623 | }
624 |
625 | itemsPicked.push(item);
626 | }
627 |
628 | itemPos += settings.game == `Retail` ? lootWindow.itemHeight + lootWindow.itemHeightAdd : lootWindow.itemHeight;
629 | }
630 |
631 | if(settings.useInt && itemsPicked.length > 1) {
632 | await moveTo({pos: cursorPos, randomRange: 5});
633 | }
634 |
635 | await sleep(350); // disappearing loot window delay
636 | if (settings.game == 'Leg' ? items.length != itemsPicked.length : await lootExitZone.isLootOpened(cursorPos)) {
637 |
638 | if (config.reaction) {
639 | await sleep(random(config.reactionDelay.from, config.reactionDelay.to));
640 | }
641 |
642 | if((config.closeLoot == `mouse` || config.closeLoot == `mouse+esc`) && lootWindow.exitButton) {
643 | if(config.closeLoot == `mouse`) {
644 | await moveTo({ pos: {
645 | x: cursorPos.x + lootWindow.exitButton.x,
646 | y: cursorPos.y - lootWindow.exitButton.y
647 | }, randomRange: 2});
648 | await mouse.toggle("left", true, delay);
649 | await mouse.toggle("left", false, delay);
650 |
651 | if(settings.useInt) {
652 | await moveTo({ pos: cursorPos, randomRange: 2 });
653 | }
654 | }
655 |
656 | if(config.closeLoot == `mouse+esc`) {
657 | if(random(0, 100) > 50) {
658 | await keyboard.sendKey("escape", delay);
659 | } else {
660 | await moveTo({ pos: {
661 | x: cursorPos.x + lootWindow.exitButton.x,
662 | y: cursorPos.y - lootWindow.exitButton.y
663 | }, randomRange: 2});
664 | await mouse.toggle("left", true, delay);
665 | await mouse.toggle("left", false, delay);
666 |
667 | if(settings.useInt) {
668 | await moveTo({ pos: cursorPos, randomRange: 2 });
669 | }
670 | }
671 | }
672 | } else {
673 | await keyboard.sendKey("escape", delay);
674 | }
675 | }
676 |
677 |
678 | return itemsPicked;
679 | };
680 |
681 | const dynamicThreshold = () => {
682 | settings.threshold = settings.threshold - config.dynamicThresholdValue;
683 | fishingZone = createFishingZone(getDataFrom, Zone.from(screenSize).toRel(config.relZone), screenSize, settings, config);
684 | }
685 |
686 | dynamicThreshold.on = config.dynamicThreshold && !settings.autoTh;
687 | dynamicThreshold.limit = () => settings.threshold < 20;
688 |
689 | const hookBobber = async (pos) => {
690 | if (config.reaction) {
691 | await sleep(random(config.reactionDelay.from, config.reactionDelay.to));
692 | }
693 | let caught = false;
694 |
695 | if(!pos) { // in case recasting if it's stated in maxFishTimeAfter
696 | return caught;
697 | }
698 |
699 | await action(async () => {
700 | if(settings.useInt) {
701 | await keyboard.toggleKey(settings.intKey, true, delay);
702 | await keyboard.toggleKey(settings.intKey, false, delay);
703 | } else {
704 | await moveTo({ pos, randomRange: 5});
705 |
706 | if (config.shiftClick) {
707 | await keyboard.toggleKey("shift", true, delay);
708 | await mouse.toggle(config.catchFishButton, true, delay);
709 | await mouse.toggle(config.catchFishButton, false, delay);
710 | await keyboard.toggleKey("shift", false, delay);
711 | } else {
712 | await mouse.toggle(config.catchFishButton, true, delay);
713 | await mouse.toggle(config.catchFishButton, false, delay);
714 | }
715 | }
716 |
717 | await sleep(250);
718 | if (!(await notificationZone.check("warning")) && !pos.missedIntentionally) {
719 | caught = true;
720 | if (config.whitelist) {
721 | let itemsPicked = await pickLoot();
722 | if(itemsPicked.length > 0) {
723 | caught = itemsPicked.toString();
724 | }
725 | }
726 | }
727 | });
728 | if(!config.whitelist) {
729 | await sleep(config.closeLootDelay);
730 | } else {
731 | await sleep(150);
732 | }
733 |
734 | if (config.sleepAfterHook) {
735 | await sleep(random(config.afterHookDelay.from, config.afterHookDelay.to));
736 | }
737 |
738 | return caught;
739 | };
740 |
741 |
742 | const doAfterTimer = async (onError, wins) => {
743 | if(config.afterTimer == `HS` || config.afterTimer == `HS + Quit`) {
744 | await action(async () => {
745 | await keyboard.sendKey(config.hsKey, delay);
746 | }, true);
747 | await sleep(config.hsKeyDelay * 1000);
748 | }
749 |
750 | state.status = `stop`;
751 |
752 | if(config.afterTimer == `HS + Quit` || config.afterTimer == `Quit`) {
753 | if(wins.every(win => win.state.status == `stop`)) {
754 | if(config.timerShutDown) {
755 | await keyboard.sendKey(`lWin`, delay);
756 | await sleep(random(1000, 2000));
757 | await keyboard.printText(`cmd`, delay);
758 | await sleep(random(1000, 2000));
759 | await keyboard.sendKey(`enter`, delay);
760 | await sleep(random(1000, 2000));
761 | await keyboard.printText(`shutdown -s -t 10`, delay);
762 | await keyboard.sendKey(`enter`, delay);
763 | }
764 | app.quit();
765 | }
766 | workwindow.close();
767 | }
768 |
769 | if(wins.every(win => win.state.status == `stop`)) {
770 | onError();
771 | }
772 | }
773 |
774 | doAfterTimer.on = config.timer;
775 | doAfterTimer.timer = createTimer(() => config.timerTime * 1000 * 60);
776 |
777 | const checkConfirm = async () => {
778 | if(config.checkConfirm && !config.whitelist) {
779 | await sleep(250) // wait for the window to appear
780 | const needsConfirm = await checkRedButton(confirmationWindow);
781 | if(needsConfirm) {
782 | await action(async () => {
783 | await mouse.toggle('left', true, delay);
784 | await mouse.toggle('left', false, delay);
785 | });
786 | }
787 | }
788 | }
789 |
790 | return {
791 | checkConfirm,
792 | doAfterTimer,
793 | dynamicThreshold,
794 | logOut,
795 | preliminaryChecks,
796 | findAllBobberColors,
797 | randomSleep,
798 | applyLures,
799 | castFishing,
800 | findBobber,
801 | highlightBobber,
802 | checkBobber,
803 | hookBobber
804 | };
805 | };
806 |
807 | module.exports = createBot;
808 |
--------------------------------------------------------------------------------
/app/bot/createBots.js:
--------------------------------------------------------------------------------
1 | const runBot = require("./runBot.js");
2 | const createBot = require("./createBot.js");
3 |
4 | const { convertMs } = require('../utils/time.js');
5 | const Stats = require('./stats.js');
6 |
7 | const { createIdLog } = require("../utils/logger.js");
8 | const EventLine = require("../utils/eventLine.js");
9 | const { setWorker } = require("../utils/textReader.js");
10 |
11 | const createWinSwitch = require("../game/winSwitch.js");
12 | let properLanguages = {eng: `English`, spa: "Spanish", spa_old: "Spanish Old", deu: "Deutsch", por: "Português", fra: "Français", ita: "Italiano", chi_sim: "Simplified Chinese", chi_tra: "Traditional Chinese", kor: "Korean", rus: "Russian"};
13 |
14 | const createBots = async (games, settings, config, log) => {
15 | const winSwitch = createWinSwitch(new EventLine());
16 |
17 | if(config.patch[settings.game].whitelist) {
18 | log.send(`Downloading data for ${properLanguages[config.patch[settings.game].whitelistLanguage]} language, it might take a while...`);
19 | await setWorker(config.patch[settings.game].whitelistLanguage);
20 | }
21 |
22 | games = [games[0]];
23 |
24 | const bots = games.map((game, i) => {
25 | let state = { status: "initial", startTime: Date.now() };
26 | return {
27 | bot: createBot(game, {config: config.patch[settings.game], settings}, winSwitch, state),
28 | log: createIdLog(log, ++i),
29 | state,
30 | stats: new Stats()
31 | }
32 | });
33 |
34 | return {
35 | startBots(onError) {
36 | log.send("Starting the bot...")
37 |
38 | bots.forEach((bot) => {
39 | runBot(bot, onError, bots)
40 | .then(() => {
41 | log.setState(true);
42 | bot.stats.show().forEach((stat) => bot.log.ok(stat));
43 | bot.log.ok(`Time Passed: ${convertMs(Date.now() - bot.state.startTime)}`);
44 | })
45 | .catch((error) => {
46 | if(bot.state.status == `stop`) {
47 | return;
48 | } else {
49 | bot.state.status = "stop";
50 | }
51 |
52 | if (bots.every(({state}) => state.status == "stop")) {
53 | onError();
54 | }
55 | log.setState(true);
56 | if(process.env.NODE_ENV == `dev`) {
57 | bot.log.err(`${error.message, error.stack}`);
58 | } else {
59 | bot.log.err(`${error.message}`);
60 | }
61 |
62 |
63 | bot.stats.show().forEach((stat) => bot.log.ok(stat));
64 | bot.log.ok(`Time Passed: ${convertMs(Date.now() - bot.state.startTime)}`);
65 | });
66 | })
67 | },
68 | stopBots() {
69 | log.send('Stopping the bot...')
70 | log.setState(false);
71 | bots.forEach(({state}) => state.status = "stop");
72 | },
73 | };
74 | };
75 |
76 | module.exports = createBots;
77 |
--------------------------------------------------------------------------------
/app/bot/fishingZone.js:
--------------------------------------------------------------------------------
1 | const createRgb = require('../utils/rgb.js');
2 | const Vec = require('../utils/vec.js');
3 | const Jimp = require('jimp');
4 |
5 | const pixelmatch = require('pixelmatch');
6 |
7 | const isInLimits = ({ x, y }, { width, height }) => {
8 | return x >= 0 && y >= 0 && x < width && y < height;
9 | };
10 |
11 | const isOverThreshold = ([r, g, b], threshold) => (r - Math.max(g, b)) > threshold;
12 | const isCloseEnough = ([_, g, b], closeness) => Math.abs(g - b) <= closeness;
13 |
14 | const isRed = (threshold, closeness = 255, size = 255, upperLimit = 335) => ([r, g, b]) => isOverThreshold([r, g, b], threshold) &&
15 | isCloseEnough([r, g, b], closeness) &&
16 | g < size && b < size && r <= upperLimit && g != 0 && b != 0;
17 |
18 | const isBlue = (threshold, closeness = 255, size = 255, upperLimit = 335) => ([r, g, b]) => isOverThreshold([b, g, r], threshold) &&
19 | isCloseEnough([b, g, r], closeness) &&
20 | r < size && g < size && b <= upperLimit && r != 0 && g != 0;
21 |
22 | let imgAroundBobberPrev;
23 | let pixelMatchMax;
24 |
25 | const createFishingZone = (getDataFrom, zone, screenSize, { game, checkLogic, autoSens, threshold, bobberColor, autoTh, bobberSensitivity: sensitivity}, {findBobberDirection: direction, splashColor}) => {
26 | let checkAboveCompensateValue = 0;
27 | const doubleZoneSize = Math.round((screenSize.height / 1080) * 50); // 25
28 | sensitivity = (game == `Retail` || game == `Vanilla (splash)` ? 30 - sensitivity[game] : 10 - sensitivity[game]) || 1;
29 |
30 | if(checkLogic == 'pixelmatch') {
31 | if(autoSens) {
32 | sensitivity = 0.25;
33 | } else {
34 | sensitivity = game == `Retail` || game == `Vanilla (splash)` ? sensitivity / 30 : sensitivity / 10;
35 | }
36 | }
37 |
38 | let isBobber = bobberColor == `red` ? isRed(threshold, 50) : isBlue(threshold, 50);
39 | let saturation = bobberColor == `red` ? [80, 0, 0] : [0, 0, 80];
40 | const looksLikeBobber = (size) => (pos, color, rgb) => {
41 | let pointsFound = pos.getPointsAround(Math.round(size * (screenSize.height / 1080)) || 1).filter((pos) => isBobber(rgb.colorAt(pos)));
42 | if(pointsFound.length >= Math.round(8 * (screenSize.height / 1080))) {
43 | return true;
44 | }
45 | }
46 | let filledBobber;
47 |
48 | return {
49 | async findBobber(exception, log, highlight) {
50 |
51 | checkAboveCompensateValue = 0;
52 | imgAroundBobberPrev = null;
53 | pixelMatchMax = 0;
54 |
55 | let rgbZone = zone;
56 | if(highlight && (game == `Classic` || game == `Cata Classic` || game == `Retail`)) {
57 | rgbZone = {x: highlight.x - doubleZoneSize, y: highlight.y - doubleZoneSize, width: doubleZoneSize * 2, height: doubleZoneSize * 2};
58 | if(rgbZone.x < zone.x) rgbZone.x = zone.x;
59 | if(rgbZone.y < zone.y) rgbZone.y = zone.y;
60 | if(rgbZone.x + rgbZone.width > zone.x + zone.width) rgbZone.x = zone.x + zone.width - rgbZone.width;
61 | if(rgbZone.y + rgbZone.height > zone.y + zone.height) rgbZone.y = zone.y + zone.height - rgbZone.height;
62 | }
63 |
64 | let rgb = createRgb(await getDataFrom(rgbZone));
65 | rgb.saturate(...saturation)
66 |
67 | if(exception) {
68 | rgb.cutOut(exception);
69 | }
70 |
71 | let bobber;
72 | if(autoTh) {
73 | bobber = this._findMost(rgb);
74 | if(bobber && process.env.NODE_ENV == `dev`) {
75 | log.err(`[DEBUG] Color Found: ${bobber.color}, at: ${bobber.pos.x},${bobber.pos.y}`);
76 | }
77 | if(!bobber) return;
78 | } else {
79 | bobber = rgb.findColors({
80 | isColor: isBobber,
81 | atFirstMet: true,
82 | saveColor: true,
83 | task: looksLikeBobber(1),
84 | direction
85 | });
86 | }
87 |
88 | if(checkLogic == `pixelmatch`) {
89 | return bobber.pos.plus(rgbZone);
90 | }
91 |
92 | if(!bobber) return; // In case the bobber wasn't found in either _findMost or manually - recast.
93 |
94 | if(autoTh || direction == `center` || autoSens) {
95 | const doubleZoneDims = {x: rgbZone.x + bobber.pos.x - doubleZoneSize,
96 | y: rgbZone.y + bobber.pos.y - doubleZoneSize,
97 | width: doubleZoneSize * 2,
98 | height: doubleZoneSize * 2};
99 |
100 | if(doubleZoneDims.x < rgbZone.x) doubleZoneDims.x = rgbZone.x;
101 | if(doubleZoneDims.y < rgbZone.y) doubleZoneDims.y = rgbZone.y;
102 | if(doubleZoneDims.x + doubleZoneDims.width > rgbZone.x + rgbZone.width) doubleZoneDims.x = rgbZone.x + rgbZone.width - doubleZoneDims.width;
103 | if(doubleZoneDims.y + doubleZoneDims.height > rgbZone.y + rgbZone.height) doubleZoneDims.y = rgbZone.y + rgbZone.height - doubleZoneDims.height;
104 |
105 | let doubleZoneData = await getDataFrom(doubleZoneDims);
106 |
107 | if(process.env.NODE_ENV == `dev`) {
108 | const img = await Jimp.read(doubleZoneData);
109 | const date = new Date()
110 | const name = `doubleZoneData-${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}.png`
111 | img.write(`${__dirname}/../debug/${name}`);
112 | }
113 |
114 | let rgbAroundBobber = createRgb(doubleZoneData);
115 | rgbAroundBobber.saturate(...saturation);
116 |
117 | if(autoTh) {
118 | let colorPrev = null;
119 | const mostRedPoints = [];
120 | let errorStartTime = Date.now();
121 | for(;Date.now() - errorStartTime < 2000;) {
122 | let mostRedPoint = this._findMost(rgbAroundBobber);
123 |
124 | if(!mostRedPoint) {
125 | return;
126 | }
127 |
128 | let [r, g, b] = mostRedPoint.color;
129 | let colorNow = r - Math.max(g, b) - (g + b);
130 |
131 | if(!colorPrev) {
132 | colorPrev = colorNow;
133 | }
134 |
135 | let colorDiffPercent = (colorNow / colorPrev) * 100;
136 |
137 | if(colorDiffPercent < 50) {
138 | break;
139 | }
140 |
141 | rgbAroundBobber.cutOut([mostRedPoint.pos]);
142 | mostRedPoints.push(mostRedPoint);
143 | }
144 |
145 | if(mostRedPoints.length == 0) {
146 | return;
147 | }
148 |
149 | filledBobber = mostRedPoints.map((point) => ({
150 | color: point.color,
151 | pos: new Vec(point.pos.x + doubleZoneDims.x - rgbZone.x, point.pos.y + doubleZoneDims.y - rgbZone.y)
152 | }));
153 |
154 | let mostLeft = mostRedPoints.reduce((a, b) => a.pos.x < b.pos.x ? a : b);
155 | let mostRight = mostRedPoints.reduce((a, b) => a.pos.x > b.pos.x ? a : b);
156 | let middleValue = (mostLeft.pos.x + mostRight.pos.x) / (bobberColor == `red` ? 2 : 1.5); // position on the feather
157 | let mostTop = mostRedPoints.reduce((a, b) => a.pos.y < b.pos.y ? a : b);
158 | let mostTopMiddle = mostRedPoints.reduce((a, b) => {
159 | if(
160 | Math.abs(a.pos.x - middleValue) + (a.pos.y - mostTop.pos.y)
161 | < Math.abs(b.pos.x - middleValue) + (b.pos.y - mostTop.pos.y)
162 | ) {
163 | return a;
164 | } else {
165 | return b;
166 | }
167 | });
168 |
169 | bobber.color = mostTopMiddle.color;
170 | bobber.pos = mostTopMiddle.pos.plus({x: doubleZoneDims.x, y: doubleZoneDims.y});
171 | this._findThreshold(bobber);
172 | } else {
173 | /* if direction == center */
174 | filledBobber = rgbAroundBobber.findColors({isColor: isBobber, saveColor: true});
175 | bobber = rgbAroundBobber.findColors({
176 | isColor: isBobber,
177 | atFirstMet: true,
178 | saveColor: true,
179 | direction: `normal`,
180 | task: game == `Vanilla` ? null : looksLikeBobber(1)
181 | })
182 |
183 | if(!bobber) {
184 | return;
185 | }
186 |
187 | bobber.pos = bobber.pos.plus({x: doubleZoneDims.x, y: doubleZoneDims.y});
188 | }
189 |
190 | if(autoSens) {
191 | await this.adjustSensitivity(filledBobber.length);
192 | }
193 |
194 | return bobber.pos;
195 | }
196 |
197 | return bobber.pos.plus(rgbZone);
198 | },
199 |
200 | _findMost(rgb) {
201 | let initialThColors = rgb.findColors({
202 | isColor: bobberColor == `red` ? isRed(0) : isBlue(0),
203 | saveColor: true
204 | });
205 |
206 | if(!initialThColors) return;
207 |
208 | let bobber = initialThColors.reduce((a, b) => {
209 | let [rA, gA, bA] = a.color;
210 | let [rB, gB, bB] = b.color;
211 |
212 | let maxARed = gA + bA;
213 | let maxBRed = gB + bB;
214 |
215 | let maxABlue = rA + gA;
216 | let maxBBlue = rB + gB;
217 |
218 | let colorA = bobberColor == `red` ? (rA - Math.max(gA, bA)) - maxARed : (bA - Math.max(gA, rA)) - maxABlue;
219 | let colorB = bobberColor == `red` ? (rB - Math.max(gB, bB)) - maxBRed : (bB - Math.max(gB, rB)) - maxBBlue;
220 |
221 | if(colorA > colorB) {
222 | return a;
223 | } else {
224 | return b;
225 | }
226 | });
227 |
228 | return bobber;
229 | },
230 |
231 | _findThreshold(bobber, thCoof = .75) { // .5
232 | let newThreshold = (([r, g, b]) => bobberColor == `red` ? (r - (Math.max(g, b))) * thCoof : (b - Math.max(g, r)) * thCoof)(bobber.color); // for doubleZoneSearching searching half of the color foundo on threshold
233 | isBobber = bobberColor == `red` ? isRed(newThreshold, 50) : isBlue(newThreshold, 50); // 50?
234 | },
235 |
236 | async adjustSensitivity(bobberSize) {
237 | if(game == `Retail`) {
238 | let calculatedSens = Math.round(Math.sqrt(bobberSize / (bobberColor == `red` ? 3 : 2.5))); // 4 2.5
239 | if(calculatedSens < 3) calculatedSens = 3;
240 | sensitivity = calculatedSens;
241 | } else {
242 | if(game == `Vanilla`) {
243 | sensitivity = 2;
244 | } else {
245 | sensitivity = Math.max(Math.round((screenSize.height / 1080) * (bobberColor == `red` ? 3 : 2)), 2);
246 | }
247 | }
248 | },
249 |
250 | async checkBobberPrint(pos) {
251 | let rgb = createRgb(await getDataFrom({x: pos.x - sensitivity, y: pos.y - sensitivity, width: sensitivity * 2, height: sensitivity * 2}));
252 | rgb.saturate(...saturation);
253 | let bobber = rgb.findColors({
254 | isColor: isBobber,
255 | atFirstMet: true
256 | });
257 | if(bobber) {
258 | return true;
259 | }
260 | },
261 |
262 | async checkBobberPrintSplash(pos) {
263 | let rgb = createRgb(await getDataFrom({x: pos.x - sensitivity, y: pos.y - sensitivity, width: sensitivity * 2, height: sensitivity * 2}));
264 | rgb.saturate(...saturation);
265 | let whiteColors = rgb.findColors({
266 | isColor: ([r, g, b]) => r > splashColor && g > splashColor && b > splashColor,
267 | });
268 | if((whiteColors && whiteColors.length > 10) || !(await this.checkBobberPrint(pos))) {
269 | return true;
270 | }
271 | },
272 |
273 | async checkPixelMatch(bobber, startTime) {
274 | let imgAroundBobber = await getDataFrom({x: bobber.x - doubleZoneSize,
275 | y: bobber.y - doubleZoneSize,
276 | width: doubleZoneSize * 2,
277 | height: doubleZoneSize * 2});
278 |
279 | if(imgAroundBobberPrev) {
280 | let pixelMatchTh = pixelmatch(imgAroundBobberPrev.data, imgAroundBobber.data, null, imgAroundBobber.width, imgAroundBobber.height, {threshold: 0.1}); // 0.1 for classic
281 | if(Date.now() - startTime < 1250) {
282 | if(pixelMatchTh > pixelMatchMax) {
283 | pixelMatchMax = pixelMatchTh;
284 | }
285 |
286 | } else {
287 | if(pixelMatchTh > pixelMatchMax + (pixelMatchMax * sensitivity)) {
288 | return true;
289 | }
290 | }
291 | } else {
292 | imgAroundBobberPrev = imgAroundBobber;
293 | }
294 | },
295 |
296 | async checkAroundBobber(bobberPos) {
297 | for(let pos of bobberPos.getPointsAround()) {
298 | if(await this.isBobber(pos)) {
299 | return pos;
300 | }
301 | }
302 | },
303 |
304 | async checkBelow(pos) {
305 | for(let y = 1; y < sensitivity; y++) {
306 | let pointsBelow = [pos.plus({x: -1, y}), pos.plus({x: 0, y}), pos.plus({x: 1, y})];
307 | for(let point of pointsBelow) {
308 | if(await this.isBobber(point)) {
309 | checkAboveCompensateValue++;
310 | return pointsBelow[1];
311 | }
312 | }
313 | }
314 | },
315 |
316 | async checkAbove(pos) {
317 | let previous = pos;
318 | for(let i = 0; i < checkAboveCompensateValue; i++) {
319 | let posAbove = previous.plus({x: 0, y: -1});
320 | if(!(await this.isBobber(posAbove))) {
321 | return previous;
322 | } else {
323 | checkAboveCompensateValue--;
324 | previous = posAbove;
325 | }
326 | }
327 | return previous;
328 | },
329 |
330 | async isBobber(pos) {
331 | if(!isInLimits({ x: pos.x - zone.x, y: pos.y - zone.y }, zone)) {
332 | return;
333 | }
334 | let pointRgb = createRgb(await getDataFrom({x: pos.x, y: pos.y, width: 1, height: 1}));
335 | pointRgb.saturate(...saturation)
336 | if(isBobber(pointRgb.colorAt({ x: 0, y: 0 }))) {
337 | return true;
338 | }
339 | },
340 |
341 | async checkColor() {
342 | let rgb = createRgb(await getDataFrom(zone));
343 | let colors = rgb.findColors({
344 | isColor: bobberColor == `red` ? isRed(0) : isBlue(0),
345 | });
346 |
347 | return colors ? (colors.length / (zone.width * zone.height)) * 100 : 0;
348 | },
349 |
350 | async changeColor() {
351 | bobberColor = bobberColor == `red` ? `blue` : `red`;
352 | isBobber = bobberColor == `red` ? isRed(threshold, 50) : isBlue(threshold, 50); // 50?
353 | saturation = bobberColor == `red` ? [80, 0, 0] : [0, 0, 80];
354 | },
355 |
356 | async getBobberPrint(wobble) {
357 | let rest = [];
358 | if(autoTh) {
359 | if(!filledBobber) {
360 | return;
361 | }
362 | rest = filledBobber.map(({pos}) => pos);
363 | } else {
364 | let rgb = createRgb(await getDataFrom(zone));
365 | rgb.saturate(...saturation);
366 | rest = rgb.findColors({ isColor: isBobber, limit: 5000});
367 | }
368 |
369 | if(!rest) return;
370 |
371 | let result = [...rest];
372 | rest.forEach(restPoint => {
373 | restPoint.getPointsAround(wobble).forEach(aroundPoint => {
374 | if(!result.some(resultPoint => resultPoint.x == aroundPoint.x && resultPoint.y == aroundPoint.y)) {
375 | result.push(aroundPoint);
376 | }
377 | })
378 | });
379 |
380 | return result;
381 | }
382 | }
383 | };
384 |
385 | module.exports = createFishingZone;
386 |
--------------------------------------------------------------------------------
/app/bot/lootExitZone.js:
--------------------------------------------------------------------------------
1 | const createRgb = require('../utils/rgb.js');
2 | const Jimp = require('jimp');
3 |
4 | const createLootExitZone = ({ getDataFrom, lootWindow, size }) => {
5 | const isYellow = ([r, g, b]) => r - b > 135 && g - b > 135;
6 | return {
7 | async isLootOpened(cursorPos) {
8 | const zone = {x: cursorPos.x + lootWindow.exitButton.x - size,
9 | y: cursorPos.y - lootWindow.exitButton.y - size,
10 | width: size * 2,
11 | height: size * 2}
12 |
13 | let rgb = createRgb(await getDataFrom(zone));
14 |
15 | if(process.env.NODE_ENV == `dev`) {
16 | const img = await Jimp.read(rgb.getBitmap());
17 | const date = new Date()
18 | const name = `test-lootExitZone-${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}.png`
19 | img.write(`${__dirname}/../debug/${name}`);
20 | }
21 |
22 | let result = rgb.findColors({
23 | isColor: isYellow,
24 | atFirstMet: true
25 | });
26 |
27 | return result;
28 | }
29 | }
30 | };
31 |
32 | module.exports = createLootExitZone;
33 |
--------------------------------------------------------------------------------
/app/bot/lootZone.js:
--------------------------------------------------------------------------------
1 | const createRgb = require('../utils/rgb.js');
2 | const Jimp = require('jimp');
3 |
4 | const createLootZone = ({ getDataFrom, zone }) => {
5 | let colors = {
6 | blue: ([r, g, b]) => b - r > 80 && b - g > 80,
7 | green: ([r, g, b]) => g - r > 80 && g - b > 80,
8 | purple: ([r, g, b]) => r - g > 80 && b - g > 80
9 | };
10 |
11 | return {
12 | async findItems(...types) {
13 | let rgb = createRgb(await getDataFrom(zone));
14 |
15 | if(process.env.NODE_ENV == `dev`) {
16 | const img = await Jimp.read(rgb.getBitmap());
17 | const date = new Date()
18 | const name = `test-lootZone-${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}.png`
19 | img.write(`${__dirname}/../debug/${name}`);
20 | }
21 |
22 | return types.some(type => rgb.findColors({
23 | isColor: colors[type],
24 | atFirstMet: true
25 | }));
26 | }
27 | }
28 | };
29 |
30 | module.exports = createLootZone;
31 |
--------------------------------------------------------------------------------
/app/bot/notificationZone.js:
--------------------------------------------------------------------------------
1 | const createRgb = require("../utils/rgb.js");
2 | const Jimp = require('jimp');
3 |
4 | const createNotificationZone = ({ getDataFrom, zone }) => {
5 | const notifications = {
6 | isWarning: ([r, g, b]) => r - b > 200 && g - b > 200,
7 | isError: ([r, g, b]) => r - g > 220 && r - b > 220
8 | }
9 |
10 | return {
11 | async check(...type) {
12 | const colors = type.map((type) => {
13 | switch (type) {
14 | case "warning": {
15 | return notifications.isWarning;
16 | }
17 | case "error": {
18 | return notifications.isError;
19 | }
20 | }
21 | });
22 |
23 | for(const color of colors) {
24 | let data = await getDataFrom(zone);
25 | let rgb = createRgb(data);
26 |
27 | if(process.env.NODE_ENV == `dev`) {
28 | const img = await Jimp.read(rgb.getBitmap());
29 | const date = new Date()
30 | const name = `test-notificationZone-${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}.png`
31 | img.write(`${__dirname}/../debug/${name}`);
32 | }
33 |
34 | let foundColor = rgb.findColors({
35 | isColor: color,
36 | atFirstMet: true
37 | });
38 | if(foundColor) {
39 | return true;
40 | }
41 | }
42 | },
43 | };
44 | };
45 |
46 | module.exports = createNotificationZone;
47 |
--------------------------------------------------------------------------------
/app/bot/redButtonZone.js:
--------------------------------------------------------------------------------
1 | const createRgb = require("../utils/rgb.js");
2 | const Jimp = require('jimp');
3 |
4 | const mouseWithinZone = (mouse, zone) => {
5 | return (
6 | mouse.x - zone.x > 0 &&
7 | mouse.y - zone.y > 0 &&
8 | mouse.x < zone.x + zone.width &&
9 | mouse.y < zone.y + zone.height
10 | );
11 | };
12 |
13 |
14 | const createRedButtonZone = ({getDataFrom, zone}) => {
15 | const isRed = ([r, g, b]) => r - g > 125 && r - b > 125;
16 | const isYellow = ([r, g, b]) => r - b > 175 && g - b > 175;
17 | const isWhite = ([r, g, b]) => r > 220 && g > 220 && b > 220;
18 | return {
19 | async isOn(mousePos) {
20 | const rgb = createRgb(await getDataFrom(zone));
21 |
22 | if(process.env.NODE_ENV == `dev`) {
23 | const img = await Jimp.read(rgb.getBitmap());
24 | const date = new Date()
25 | const name = `test-redButtonZone-before-${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}.png`
26 | img.write(`${__dirname}/../debug/${name}`);
27 | }
28 |
29 | let red = rgb.findColors({isColor: isRed, atFirstMet: true});
30 | let yellow = mouseWithinZone(mousePos, zone) || rgb.findColors({isColor: isYellow, atFirstMet: true});
31 | if(red && yellow) {
32 | return {red, yellow};
33 | }
34 | },
35 |
36 | async isOnAfterHighlight() {
37 | const rgb = createRgb(await getDataFrom(zone));
38 |
39 | if(process.env.NODE_ENV == `dev`) {
40 | const img = await Jimp.read(rgb.getBitmap());
41 | const date = new Date()
42 | const name = `test-redButtonZone-after-${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}.png`
43 | img.write(`${__dirname}/../debug/${name}`);
44 | }
45 |
46 | return rgb.findColors({isColor: isWhite, atFirstMet: true})
47 | }
48 | }
49 | };
50 |
51 | module.exports = createRedButtonZone;
52 |
--------------------------------------------------------------------------------
/app/bot/runBot.js:
--------------------------------------------------------------------------------
1 | const runBot = async ({ bot, log, state, stats }, onError, wins) => {
2 | const {
3 | dynamicThreshold,
4 | logOut,
5 | preliminaryChecks,
6 | findAllBobberColors,
7 | randomSleep,
8 | applyLures,
9 | castFishing,
10 | findBobber,
11 | highlightBobber,
12 | checkBobber,
13 | hookBobber,
14 | doAfterTimer,
15 | checkConfirm
16 | } = bot;
17 |
18 | const sleep = (time) => {
19 | return new Promise((resolve) => {
20 | setTimeout(resolve, time);
21 | });
22 | };
23 |
24 | const random = (from, to) => {
25 | return from + Math.random() * (to - from);
26 | };
27 |
28 | let failedCast = false;
29 | let attempts = 0;
30 | do {
31 | if (state.status == "initial") {
32 | log.send(`Preliminary checks...`);
33 | await preliminaryChecks(log);
34 | log.ok(`Everything is fine!`);
35 | if(randomSleep.on) {
36 | randomSleep.timer.start();
37 | }
38 |
39 | if(logOut.on) {
40 | logOut.timer.start();
41 | }
42 |
43 | if(doAfterTimer.on) {
44 | doAfterTimer.timer.start();
45 | }
46 | }
47 |
48 | if(doAfterTimer.on && state.status == "working" && doAfterTimer.timer.isElapsed()) {
49 | await doAfterTimer(onError, wins);
50 | }
51 |
52 | if(logOut.on && logOut.timer.isElapsed()) {
53 | log.send(`Logging out...`)
54 | await logOut(state);
55 | if(state.status == 'stop') {
56 | return;
57 | }
58 | log.send(`Logged back!`);
59 | logOut.timer.update();
60 | }
61 |
62 | if (randomSleep.on && randomSleep.timer.isElapsed()) {
63 | log.send(`Sleeping...`);
64 | await randomSleep();
65 | if(state.status == 'stop') {
66 | return;
67 | }
68 | randomSleep.timer.update();
69 | }
70 |
71 | if (applyLures.on && applyLures.timer.isElapsed()) {
72 | log.send(`Applying lures...`);
73 | await applyLures();
74 | applyLures.timer.update();
75 | }
76 |
77 | findBobber.memory = await findAllBobberColors();
78 |
79 |
80 | if(failedCast) {
81 | let randomFailed = random(500, 5000);
82 | log.warn(`Sleeping for ${Math.floor(randomFailed)} ms.`)
83 | await sleep(randomFailed);
84 | }
85 | log.send(`Casting fishing...`);
86 | await castFishing(state);
87 |
88 | log.send(`Looking for the bobber...`);
89 | let bobber = await findBobber(log);
90 |
91 | if(bobber) {
92 | bobber = await highlightBobber(bobber, log);
93 | }
94 |
95 | if (bobber) {
96 | failedCast = false;
97 | log.ok(`Found the bobber!`);
98 | attempts = 0;
99 | } else {
100 | failedCast = true;
101 | stats.confused++;
102 | log.err(`Can't find the bobber, recast.`);
103 | if (++attempts == findBobber.maxAttempts) {
104 | if(dynamicThreshold.on && !dynamicThreshold.limit()) {
105 | dynamicThreshold();
106 | attempts = 0;
107 | } else {
108 | throw new Error(
109 | `Have tried ${findBobber.maxAttempts} attempts to find the bobber and failed: decrease the red color "threshold" value or change the fishing place.`
110 | );
111 | }
112 | }
113 | continue;
114 | }
115 |
116 | log.send(`Checking the hook...`);
117 | if ((bobber = await checkBobber(bobber, state))) {
118 | let isHooked = await hookBobber(bobber);
119 |
120 | if(bobber.missedIntentionally) {
121 | stats.misspurpose++;
122 | log.warn(`Missed the fish on purpose!`);
123 | continue;
124 | }
125 |
126 | if (isHooked) {
127 | stats.caught++;
128 | log.ok(`Caught ${typeof isHooked == `boolean` ? `the fish!` : isHooked}`);
129 |
130 | await checkConfirm();
131 |
132 | continue;
133 | }
134 | }
135 |
136 | if (state.status == "working") {
137 | stats.miss++;
138 | log.warn(`Missed the fish!`);
139 | }
140 | } while (state.status == "working");
141 | };
142 |
143 | module.exports = runBot;
144 |
--------------------------------------------------------------------------------
/app/bot/stats.js:
--------------------------------------------------------------------------------
1 | const getPercent = (value, total) => {
2 | return Math.ceil((value / (total || 1)) * 100 * 100) / 100;
3 | };
4 |
5 | class Stats {
6 | constructor() {
7 | this.caught = 0;
8 | this.miss = 0;
9 | this.confused = 0;
10 | this.misspurpose = 0;
11 | }
12 |
13 | get total() {
14 | return this.caught + this.miss + this.misspurpose;
15 | }
16 |
17 | show() {
18 | return [
19 | `Total: ${this.total}`,
20 | `Caught: ${this.caught} (${getPercent(this.caught, this.total)}%)`,
21 | `Missed: ${this.miss} (${getPercent(this.miss, this.total)}%)`,
22 | `Missed on purpose: ${this.misspurpose} (${getPercent(this.misspurpose, this.total)}%)`,
23 | `Couldn't recognize: ${this.confused} (${getPercent(this.confused, this.total)}%)`
24 | ];
25 | }
26 | }
27 |
28 | module.exports = Stats;
29 |
--------------------------------------------------------------------------------
/app/config/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | "game": "Retail",
3 | "fishingKey": "1",
4 | "intKey": "f",
5 | "useInt": false,
6 | "stopKey": "delete",
7 | "threshold": 100,
8 | "bobberSensitivity": {
9 | "Retail": 25,
10 | "Cata Classic": 7,
11 | "Classic": 7,
12 | "Leg": 7,
13 | "MoP": 7,
14 | "Cata": 7,
15 | "LK Private": 7,
16 | "TBC": 7,
17 | "Vanilla": 7,
18 | "Vanilla (splash)": 10
19 | },
20 | "checkLogic": "default",
21 | "autoSens": true,
22 | "autoTh": true,
23 | "autoColor": false,
24 | "bobberColor": "red",
25 | "initial": true,
26 | "initialZone": true
27 | }
28 |
--------------------------------------------------------------------------------
/app/game/createGame.js:
--------------------------------------------------------------------------------
1 | const { Hardware, getAllWindows } = require("keysender");
2 |
3 | const findGameWindows = ({ names, classNames }) => {
4 |
5 | const wins = getAllWindows().filter(
6 | ({ title, className }) =>
7 | names.some(name => new RegExp(`${name}`).test(title)) && classNames.includes(className)
8 | );
9 |
10 | if (wins.length > 0) {
11 | return wins.map((win) => new Hardware(win.handle));
12 | }
13 | };
14 |
15 | module.exports = {
16 | findGameWindows,
17 | getAllWindows
18 | };
19 |
--------------------------------------------------------------------------------
/app/game/nut.js:
--------------------------------------------------------------------------------
1 | let { mouse, Point } = require("@nut-tree/nut-js");
2 |
3 | function getRandomControlPoint(start, end, range) {
4 | const deltaX = end.x - start.x;
5 | const deltaY = end.y - start.y;
6 |
7 | const controlPoint1 = {
8 | x: start.x + range * deltaX + Math.random() * range * deltaX,
9 | y: start.y + range * deltaY + Math.random() * range * deltaY,
10 | };
11 |
12 | const controlPoint2 = {
13 | x: start.x + (1 - range) * deltaX + Math.random() * range * deltaX,
14 | y: start.y + (1 - range) * deltaY + Math.random() * range * deltaY,
15 | };
16 |
17 | const controlPoint3 = {
18 | x: start.x + Math.random() * deltaX,
19 | y: start.y + Math.random() * deltaY,
20 | };
21 |
22 | return [controlPoint1, controlPoint2, controlPoint3];
23 | }
24 |
25 | function generateBezierPath(startPoint, endPoint, steps, range) {
26 | const controlPoints = getRandomControlPoint(startPoint, endPoint, range);
27 | const path = [];
28 |
29 | for (let t = 0; t <= 1; t += 1 / steps) {
30 | const x = Math.pow(1 - t, 3) * startPoint.x +
31 | 3 * Math.pow(1 - t, 2) * t * controlPoints[0].x +
32 | 3 * (1 - t) * Math.pow(t, 2) * controlPoints[1].x +
33 | Math.pow(t, 3) * endPoint.x;
34 |
35 | const y = Math.pow(1 - t, 3) * startPoint.y +
36 | 3 * Math.pow(1 - t, 2) * t * controlPoints[0].y +
37 | 3 * (1 - t) * Math.pow(t, 2) * controlPoints[1].y +
38 | Math.pow(t, 3) * endPoint.y;
39 |
40 | path.push({ x, y });
41 | }
42 |
43 | return path;
44 | }
45 |
46 |
47 | const random = (from, to) => {
48 | return from + Math.random() * (to - from);
49 | };
50 |
51 | const sleep = (time) => {
52 | return new Promise((resolve) => {
53 | setTimeout(resolve, time);
54 | });
55 | };
56 |
57 | function randomHumanLikeCursorEasing(x) {
58 | const oscillation = Math.sin(x * Math.PI) + (Math.random() - 0.5) * 0.1;
59 | const increasedEasingOut = 1 - Math.pow(1 - x, 4) + (Math.random() - 0.5) * 0.1;
60 | const result = 0.7 * oscillation + 0.3 * increasedEasingOut;
61 | return Math.max(0, Math.min(1, result));
62 | }
63 |
64 | module.exports = {
65 | mouse: {
66 | async humanMoveTo({from, to, speed, deviation, fishingZone}) {
67 | const distance = Math.sqrt(Math.pow(Math.round(from.x - to.x), 2) + Math.pow(Math.round(from.y - to.y), 2));
68 | const fZoneSize = Math.sqrt(Math.pow(fishingZone.width, 2) + Math.pow(fishingZone.height, 2)) * .25;
69 | /* apply distance relation to zone size only if distance is more than 5% */
70 | mouse.config.mouseSpeed = (speed * 100 * 20) * (distance > fZoneSize * .05 ? distance / fZoneSize : 0.25);
71 | const bezierPath = generateBezierPath(from, to, distance, deviation / 150);
72 | await mouse.move(bezierPath, randomHumanLikeCursorEasing);
73 | },
74 | async toggle(button, type, delay) {
75 | let buttonNumber = button == `left` ? 1 : button == `right` ? 2 : 3;
76 | if(type == true) {
77 | await mouse.pressButton(buttonNumber);
78 | } else {
79 | await mouse.releaseButton(buttonNumber);
80 | }
81 |
82 | if(Array.isArray(delay)) {
83 | await sleep(random(delay[0], delay[1]))
84 | } else {
85 | await sleep(delay);
86 | }
87 | }
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/app/game/winSwitch.js:
--------------------------------------------------------------------------------
1 | const { createTimer } = require('../utils/time.js');
2 |
3 | const windowStuck = createTimer(() => 3000);
4 |
5 | const sleep = (time) => {
6 | return new Promise((resolve) => {
7 | setTimeout(resolve, time);
8 | });
9 | };
10 |
11 | const createWinSwitch = (eventLine) => {
12 | return {
13 | execute(workwindow) {
14 | return new Promise((resolve, reject) => {
15 | eventLine.add(async () => {
16 | workwindow.setForeground();
17 | windowStuck.start();
18 | while (!workwindow.isForeground()) {
19 | if(windowStuck.isElapsed()) {
20 | this.finished();
21 | reject(new Error(`Can't set the window to foreground`));
22 | }
23 | await sleep();
24 | }
25 | resolve();
26 | });
27 | });
28 | },
29 | finished() {
30 | eventLine.remove();
31 | },
32 | };
33 | };
34 |
35 | module.exports = createWinSwitch;
36 |
--------------------------------------------------------------------------------
/app/img/add.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/add.png
--------------------------------------------------------------------------------
/app/img/fish.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/fish.png
--------------------------------------------------------------------------------
/app/img/fold.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/fold.png
--------------------------------------------------------------------------------
/app/img/grass.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/grass.png
--------------------------------------------------------------------------------
/app/img/grate.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/grate.png
--------------------------------------------------------------------------------
/app/img/hint.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/hint.png
--------------------------------------------------------------------------------
/app/img/icon-premium.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/icon-premium.ico
--------------------------------------------------------------------------------
/app/img/icon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/icon.ico
--------------------------------------------------------------------------------
/app/img/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/icon.png
--------------------------------------------------------------------------------
/app/img/install.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/install.gif
--------------------------------------------------------------------------------
/app/img/lock.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/lock.png
--------------------------------------------------------------------------------
/app/img/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/logo.png
--------------------------------------------------------------------------------
/app/img/premium.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/premium.png
--------------------------------------------------------------------------------
/app/img/remove.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/remove.png
--------------------------------------------------------------------------------
/app/img/start.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/start.png
--------------------------------------------------------------------------------
/app/img/stop.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/stop.png
--------------------------------------------------------------------------------
/app/img/unfold.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/unfold.png
--------------------------------------------------------------------------------
/app/img/youtube_icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsbots/AutoFish/8f21eff011ac763b20557240f37f4bbe10d27fb5/app/img/youtube_icon.png
--------------------------------------------------------------------------------
/app/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | 
5 |
6 | 
43 | 
[AutoFish 1.12](https://youtu.be/A3W8UuVIZTo)
46 |
47 | **Important!** The bot works only on **Windows 10/11**.
48 |
49 | ## Disclaimer :warning:
50 |
51 | **This small project was developed for educational purposes ONLY, aiming to explore the feasibility of creating a functional gaming bot using web-development technologies.**
52 |
53 | **The software provided should NEVER be used with real-life applications, games, servers etc.**
54 |
55 | **This software is not designed to be "undetectable" in any way, nor was it ever intended for such purposes. All randomness functionality is added for educational purposes only.**
56 |
57 | **No guarantees or assurances can be made regarding the functionality or outcomes of the bot, you assume full responsibility for any outcomes that may arise from using this software.**.
58 |
59 | ## Guide :blue_book:
60 |
61 | 1. Launch the game and the bot.
62 | 2. Choose the game you want the bot to work with.
63 |
64 | 
66 | 
72 | 
78 | 
84 | 
127 | 
141 | 
179 | 
208 | 
216 | 
228 | 
286 | 
306 | 
314 | 
322 | 
336 | 
346 | 
366 | 