fix: impede que o AS continue atacando após surgir captcha

browser/App.vue

@@ -30,7 +30,7 @@ watchImmediate(currentScreen, async (name) => {
 whenever(isDeimosReady, async () => {
     if (gameOriginRegex.test(location.origin)) {
         const responseTime = await Deimos.invoke('get-response-time');
-        ipcSend('update-response-time', responseTime);
+        ipcSend('browser:update-response-time', responseTime);
         aresStore.responseTime = responseTime;
     };
 });

browser/components/TheCaptchaObserver.vue

@@ -12,7 +12,7 @@ const aresStore = useAresStore();
 const { captcha } = storeToRefs(aresStore);
 
 captcha.value = thereIsBotCheck();
-watchSyncEffect(() => ipcSend('update-captcha-status', captcha.value));
+watchSyncEffect(() => ipcSend('captcha:update-status', captcha.value));
 
 const content = ref(document.querySelector<HTMLTableElement>('table#contentContainer'));
 const options: UseMutationObserverOptions = {

browser/events/plunder/index.ts

@@ -1,7 +1,13 @@
+import { ipcRenderer } from 'electron';
+import { usePlunderConfigStore } from '$renderer/stores/plunder';
 import { setPlunderConfigEvents } from '$browser/events/plunder/config';
 import { setPlunderNavigationEvents } from '$browser/events/plunder/navigation';
 
 export function setPlunderEvents() {
     setPlunderConfigEvents();
     setPlunderNavigationEvents();
+
+    const plunderConfigStore = usePlunderConfigStore();
+
+    ipcRenderer.on('plunder:stop', () => (plunderConfigStore.active = false));
 };

electron/events/browser/captcha.ts

@@ -0,0 +1,38 @@
+import { ipcMain, webContents } from 'electron';
+import { storeToRefs, watch } from 'mechanus';
+import { isUserAlias } from '$global/guards';
+import { MainProcessEventError } from '$electron/error';
+import { useAresStore, useCacheStore, usePlunderHistoryStore, PlunderHistory } from '$electron/interface';
+
+export function setCaptchaEvents() {
+    const aresStore = useAresStore();
+    const { captcha } = storeToRefs(aresStore);
+
+    const cacheStore = useCacheStore();
+    const plunderHistoryStore = usePlunderHistoryStore();
+
+    ipcMain.on('captcha:update-status', (e, status: boolean) => {
+        captcha.value = status;
+        for (const contents of webContents.getAllWebContents()) {
+            if (contents !== e.sender) {
+                contents.send('captcha:status-did-update', status);
+            };
+        };
+    });
+
+    watch(captcha, async (status) => {
+        try {
+            if (!status) return;
+            for (const contents of webContents.getAllWebContents()) {
+                contents.send('plunder:stop');
+            };
+
+            if (isUserAlias(cacheStore.userAlias)) {
+                await PlunderHistory.saveHistory(cacheStore.userAlias, plunderHistoryStore);
+            };
+
+        } catch (err) {
+            MainProcessEventError.catch(err);
+        };
+    });
+};

electron/events/browser/index.ts

@@ -0,0 +1,18 @@
+import { ipcMain } from 'electron';
+import { useAresStore } from '$electron/interface';
+import { getMainWindow } from '$electron/utils/helpers';
+import { setCaptchaEvents } from '$electron/events/browser/captcha';
+
+export function setBrowserEvents() {
+    const mainWindow = getMainWindow();
+    const aresStore = useAresStore();
+
+    ipcMain.handle('browser:get-response-time', () => aresStore.responseTime);
+
+    ipcMain.on('browser:update-response-time', (_e, time: number) => {
+        aresStore.responseTime = time;
+        mainWindow.webContents.send('response-time-did-update', time);
+    });
+
+    setCaptchaEvents();
+};

panel/events/index.ts

@@ -18,12 +18,12 @@ export function setPanelEvents() {
     const unitStore = useUnitsStore();
     const groupsStore = useGroupsStore();
 
-    ipcRenderer.on('panel:visibility-did-change', (_e, isVisible: boolean) => {
-        panelStore.isVisible = isVisible;
+    ipcRenderer.on('captcha:status-did-update', (_e, thereIsCaptcha: boolean) => {
+        aresStore.captcha = thereIsCaptcha;
     });
 
-    ipcRenderer.on('captcha-status-did-update', (_e, thereIsCaptcha: boolean) => {
-        aresStore.captcha = thereIsCaptcha;
+    ipcRenderer.on('panel:visibility-did-change', (_e, isVisible: boolean) => {
+        panelStore.isVisible = isVisible;
     });
 
     ipcRenderer.on('panel:patch-game-data', (_e, data: TribalWarsGameDataType) => {

panel/events/plunder.ts

@@ -9,6 +9,8 @@ export function setPlunderEvents() {
     const plunderConfigStore = usePlunderConfigStore();
     const plunderHistoryStore = usePlunderHistoryStore();
 
+    ipcRenderer.on('plunder:stop', () => (plunderConfigStore.active = false));
+
     // Atualiza o estado local do Plunder sempre que ocorre uma mudança.
     ipcRenderer.on('plunder:config-updated', <T extends keyof typeof plunderConfigStore>(
         _e: unknown, key: T, value: typeof plunderConfigStore[T]

panel/views/CaptchaView.vue

@@ -1,23 +1,5 @@
 <script setup lang="ts">
-import { storeToRefs } from 'pinia';
 import { NResult } from 'naive-ui';
-import { watchImmediate } from '@vueuse/core';
-import { useAresStore } from '$renderer/stores/ares';
-import { usePlunderConfigStore } from '$renderer/stores/plunder';
-import { router } from '$panel/router';
-import { ipcSend } from '$renderer/ipc';
-
-const aresStore = useAresStore();
-const plunderConfigStore = usePlunderConfigStore();
-
-const { captcha } = storeToRefs(aresStore);
-
-watchImmediate(captcha, (isActive) => {
-    if (isActive && router.currentRoute.value.name === 'am_farm') {
-        plunderConfigStore.active = false;
-        ipcSend('plunder:save-history');
-    };
-});
 </script>
 
 <template>

renderer/ipc.ts

@@ -30,7 +30,7 @@ export async function ipcInvoke(channel: 'user-alias'): Promise<UserAlias | null
 export async function ipcInvoke(channel: 'user-data-path'): Promise<string>;
 export async function ipcInvoke(channel: 'user-desktop-path'): Promise<string>;
 export async function ipcInvoke(channel: 'is-dev'): Promise<boolean>;
-export async function ipcInvoke(channel: 'get-response-time'): Promise<number>;
+export async function ipcInvoke(channel: 'browser:get-response-time'): Promise<number>;
 export async function ipcInvoke(channel: 'is-ignored-app-version', version: string): Promise<boolean>;
 
 // Configurações
@@ -104,8 +104,8 @@ export function ipcSend(channel: 'open-github-issues'): void;
 export function ipcSend(channel: 'open-app-update-window'): void;
 export function ipcSend(channel: 'download-from-url', url: string): void;
 export function ipcSend(channel: 'show-update-available-dialog', newVersion: string): void;
-export function ipcSend(channel: 'update-captcha-status', status: boolean): void;
-export function ipcSend(channel: 'update-response-time', time: number | null): void;
+export function ipcSend(channel: 'captcha:update-status', status: boolean): void;
+export function ipcSend(channel: 'browser:update-response-time', time: number | null): void;
 export function ipcSend(channel: 'electron:show-message-box', options: ElectronMessageBoxOptions): void;
 
 // Desenvolvedor

ui/components/TheResponseTime.vue

@@ -5,7 +5,7 @@ import { NTag } from 'naive-ui';
 import { ipcInvoke } from '$renderer/ipc';
 
 const responseTime = ref<number | null>(null);
-responseTime.value = await ipcInvoke('get-response-time');
+responseTime.value = await ipcInvoke('browser:get-response-time');
 
 const responseTimeTagType = computed(() => {
     if (responseTime.value) {