Improve resources to level task

src/Action/ClickButtonAction.ts

@@ -1,10 +1,14 @@
 import { ActionController, registerAction } from './ActionController';
 import { Args } from '../Command';
 import { Task } from '../Queue/TaskQueue';
+import { AbortTaskError } from '../Errors';
 
 @registerAction
 export class ClickButtonAction extends ActionController {
     async run(args: Args, task: Task): Promise<any> {
+        if (!args.selector) {
+            throw new AbortTaskError('No selector');
+        }
         const el = jQuery(args.selector);
         if (el.length === 1) {
             console.log('CLICK BUTTON', el);

src/Action/GoToPageAction.ts

@@ -1,10 +1,14 @@
 import { ActionController, registerAction } from './ActionController';
 import { Args } from '../Command';
 import { Task } from '../Queue/TaskQueue';
+import { AbortTaskError } from '../Errors';
 
 @registerAction
 export class GoToPageAction extends ActionController {
     async run(args: Args, task: Task): Promise<any> {
+        if (!args.path) {
+            throw new AbortTaskError('No path');
+        }
         window.location.assign(args.path);
     }
 }

src/Action/UpgradeResourceToLevel.ts

@@ -1,11 +1,11 @@
 import { ActionController, registerAction } from './ActionController';
 import { Args } from '../Command';
-import { ActionError, TryLaterError } from '../Errors';
+import { AbortTaskError, ActionError, TryLaterError } from '../Errors';
 import { Task } from '../Queue/TaskQueue';
 import { grabResourceDeposits } from '../Page/SlotBlock';
 import { UpgradeBuildingTask } from '../Task/UpgradeBuildingTask';
 import { ResourceDeposit } from '../Game';
-import { aroundMinutes } from '../utils';
+import { aroundMinutes, getNumber } from '../utils';
 
 @registerAction
 export class UpgradeResourceToLevel extends ActionController {
@@ -16,35 +16,38 @@ export class UpgradeResourceToLevel extends ActionController {
         }
 
         const villageId = args.villageId;
-        const requiredLevel = args.level;
-        const tasks = this.scheduler.getTaskItems();
+        if (villageId === undefined) {
+            throw new AbortTaskError('No village id');
+        }
 
-        const allUpgraded = deposits.reduce((memo, dep) => memo && dep.level >= requiredLevel, true);
+        const requiredLevel = getNumber(args.level);
 
-        if (allUpgraded) {
+        const notUpgraded = deposits.filter(dep => requiredLevel > dep.level);
+
+        if (notUpgraded.length === 0) {
             this.scheduler.removeTask(task.id);
             return;
         }
 
-        const isDepositTaskNotInQueue = (dep: ResourceDeposit) =>
+        const firstNotUpgraded = notUpgraded.sort((x, y) => x.level - y.level).shift();
+
+        if (firstNotUpgraded && this.isTaskNotInQueue(villageId, firstNotUpgraded)) {
+            this.scheduler.scheduleTask(UpgradeBuildingTask.name, { villageId, buildId: firstNotUpgraded.buildId });
+        }
+
+        throw new TryLaterError(aroundMinutes(10), 'Sleep for next round');
+    }
+
+    private isTaskNotInQueue(villageId: number, dep: ResourceDeposit): boolean {
+        const tasks = this.scheduler.getTaskItems();
+        return (
             undefined ===
             tasks.find(
                 task =>
                     task.name === UpgradeBuildingTask.name &&
                     task.args.villageId === villageId &&
                     task.args.buildId === dep.buildId
-            );
-
-        const notUpgraded = deposits.sort((x, y) => x.level - y.level).filter(isDepositTaskNotInQueue);
-
-        if (notUpgraded.length === 0) {
-            throw new TryLaterError(aroundMinutes(10), 'No available deposits');
-        }
-
-        for (let dep of notUpgraded) {
-            this.scheduler.scheduleTask(UpgradeBuildingTask.name, { villageId, buildId: dep.buildId });
-        }
-
-        throw new TryLaterError(aroundMinutes(10), 'Sleep for next round');
+            )
+        );
     }
 }

src/Command.ts

@@ -15,7 +15,9 @@ export interface Args {
     trainCount?: number;
     resources?: ResourcesInterface;
     coordinates?: CoordinatesInterface;
-    [name: string]: any;
+    level?: number;
+    selector?: string;
+    path?: string;
 }
 
 export class Command {

src/Task/ResourcesToLevel.ts

@@ -1,6 +1,6 @@
 import { Args, Command } from '../Command';
 import { Task } from '../Queue/TaskQueue';
-import { TaskController, registerTask } from './TaskController';
+import { TaskController, registerTask, ActionDefinition } from './TaskController';
 import { GoToPageAction } from '../Action/GoToPageAction';
 import { CompleteTaskAction } from '../Action/CompleteTaskAction';
 import { path } from '../utils';
@@ -8,15 +8,10 @@ import { UpgradeResourceToLevel } from '../Action/UpgradeResourceToLevel';
 
 @registerTask
 export class ResourcesToLevel extends TaskController {
-    async run(task: Task) {
-        const args: Args = { ...task.args, taskId: task.id };
-        this.scheduler.scheduleActions([
-            new Command(GoToPageAction.name, {
-                ...args,
-                path: path('/dorf1.php', { newdid: args.villageId }),
-            }),
-            new Command(UpgradeResourceToLevel.name, args),
-            new Command(CompleteTaskAction.name, args),
-        ]);
+    defineActions(task: Task): Array<ActionDefinition> {
+        return [
+            [GoToPageAction.name, { path: path('/dorf1.php', { newdid: task.args.villageId }) }],
+            [UpgradeResourceToLevel.name, {}],
+        ];
     }
 }

src/utils.ts

@@ -4,25 +4,28 @@ export function sleep(ms: number) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+function randomInRange(from: number, to: number): number {
+    const delta = to - from;
+    const variation = Math.random() * delta;
+    return from + variation;
+}
+
 export async function sleepMicro() {
-    let ms = 2000 + Math.random() * 500;
-    return await sleep(ms);
+    return await sleep(randomInRange(2000, 2500));
 }
 
 export async function sleepShort() {
-    let ms = 3000 + Math.random() * 1000;
-    return await sleep(ms);
+    return await sleep(randomInRange(3000, 4000));
 }
 
 export async function sleepLong() {
-    let ms = 120_000 + Math.random() * 300_000;
-    return await sleep(ms);
+    return await sleep(randomInRange(120_000, 420_00));
 }
 
 export function aroundMinutes(minutes: number) {
     const seconds = minutes * 60;
-    const delta = Math.floor(seconds * 0.9);
-    return seconds - delta + Math.floor(Math.random() * 2 * delta);
+    const delta = Math.floor(seconds * 0.1);
+    return randomInRange(seconds - delta, seconds + delta);
 }
 
 export async function waitForLoad() {