feat: add walking antiban tasks queue

Author: Torwent

osrs/antiban/antiban.simba

@@ -59,6 +59,7 @@ Main record to handle the built-in WaspLib antiban.
     Tasks:  array of TAntibanTask;
     Breaks: array of TBreakTask;
     Sleeps: array of TSleepTask;
+    WalkTasks:  array of TAntibanTask;
 
     OnStartTask,  OnFinishTask:  procedure(task: PAntibanTask) of object;
     OnStartBreak, OnFinishBreak: procedure(task: PBreakTask)   of object;
@@ -93,14 +94,37 @@ begin
       Result += @Self.Tasks[i];
 end;
 
+function TAntiban.GetActiveWalkTasks(): PAntibanTaskArray;
+var
+  i: Integer;
+begin
+  for i := 0 to High(Self.WalkTasks) do
+    if not Self.WalkTasks[i].Countdown.IsPaused then
+      Result += @Self.WalkTasks[i];
+end;
+
+function TAntiban.GetInactiveWalkTasks(): PAntibanTaskArray;
+var
+  i: Integer;
+begin
+  for i := 0 to High(Self.WalkTasks) do
+    if Self.WalkTasks[i].Countdown.IsPaused then
+      Result += @Self.WalkTasks[i];
+end;
+
 
 
 procedure TAntiban._UpdateTask(idx: Integer; method: TAntibanMethod; interval, randomness: Double);
 begin
   Self.Tasks[idx].Interval := interval;
   Self.Tasks[idx].Method := @method;
   Self.Tasks[idx].StdVar := randomness;
-  Self.Tasks[idx].Countdown.Start(Random(Trunc(Abs(GaussRand(Self.Tasks[idx].Interval, Self.Tasks[idx].Interval * Self.Tasks[idx].StdVar)))));
+  Self.Tasks[idx].Countdown.Start(
+    Random(Trunc(Abs(GaussRand(
+      Self.Tasks[idx].Interval,
+      Self.Tasks[idx].Interval * Self.Tasks[idx].StdVar
+    ))))
+  );
 end;
 
 procedure TAntiban._UpdateBreak(idx: Integer; interval, length, randomness, logoutChance: Double);
@@ -109,7 +133,11 @@ begin
   Self.Breaks[idx].Length := length;
   Self.Breaks[idx].StdVar := randomness;
   Self.Breaks[idx].LogoutChance := logoutChance;
-  Self.Breaks[idx].Next := GetTimeRunning() + Abs(GaussRand(Self.Breaks[idx].Interval, Self.Breaks[idx].Interval * Self.Breaks[idx].StdVar));
+  Self.Breaks[idx].Next := GetTimeRunning() +
+    Abs(GaussRand(
+      Self.Breaks[idx].Interval,
+      Self.Breaks[idx].Interval * Self.Breaks[idx].StdVar
+    ));
 end;
 
 procedure TAntiban._UpdateSleep(idx: Integer; time: String; length, randomness, logoutChance: Double);
@@ -121,6 +149,19 @@ begin
   Self.Sleeps[idx].Next := Self.TimeRunningAtClock(time, randomness);
 end;
 
+procedure TAntiban._UpdateWalkTask(idx: Integer; method: TAntibanMethod; interval, randomness: Double);
+begin
+  Self.WalkTasks[idx].Interval := interval;
+  Self.WalkTasks[idx].Method := @method;
+  Self.WalkTasks[idx].StdVar := randomness;
+  Self.WalkTasks[idx].Countdown.Start(
+    Random(Trunc(Abs(GaussRand(
+      Self.WalkTasks[idx].Interval,
+      Self.WalkTasks[idx].Interval * Self.WalkTasks[idx].StdVar
+    ))))
+  );
+end;
+
 
 (*
 ## Antiban.AddTask
@@ -131,7 +172,8 @@ Schedule a antiban task.
 An antiban task can be any procedure but they should be short actions that won't
 break your main script.
 
-`method` is a pointer to the task you want to perform. WaspLib includes a couple of them but you may make your own if you want.
+`method` is a pointer to the task you want to perform. WaspLib includes a couple
+of them but you may make your own if you want.
 
 `interval` is the aproximate interval of time that has to pass for the antiban
 task to occur and it will be repeated everytime that the interval has passed
@@ -146,25 +188,27 @@ Antiban.AddTask(@Antiban.HoverSkills, 15 * ONE_MINUTE); //Every 15 minutes the s
 *)
 procedure TAntiban.AddTask(method: TAntibanMethod; interval: Double; randomness: Double = 0.2);
 var
-  len: Integer;
+  idx: Integer;
 begin
-  len := Length(Self.Tasks);
-  SetLength(Self.Tasks, len+1);
-  Self._UpdateTask(len, @method, interval, randomness);
+  idx := Length(Self.Tasks);
+  SetLength(Self.Tasks, idx+1);
+  Self._UpdateTask(idx, @method, interval, randomness);
 end;
 
 (*
 ## Antiban.AddBreak
 ```pascal
 procedure TAntiban.AddBreak(interval, length: Double; randomness: Double = 0.2; logoutChance: Double = 0.33);
 ```
-Schedule a break. Breaks can be of short or medium length and should be shorter than any sleep breaks.
+Schedule a break. Breaks can be of short or medium length and should be shorter
+than any sleep breaks.
 
 `interval` is the aproximate interval of time that has to pass for the break to
 occur and it will be repeated everytime that interval passes and the antiban is
 checked either with {ref}`Antiban.DoBreak` or {ref}`Antiban.DoAntiban`.
 
-`length`, `randomness` and `logoutChance` are the same as {ref}`Antiban.AddSleep`.
+`length`, `randomness` and `logoutChance` are the same as
+{ref}`Antiban.AddSleep`.
 
 This break will only occur when {ref}`Antiban.DoAntiban` is called.
 
@@ -175,11 +219,11 @@ Antiban.AddBreak(30 * ONE_MINUTE, 5 * ONE_MINUTE); //Every 30 minutes the script
 *)
 procedure TAntiban.AddBreak(interval, length: Double; randomness: Double = 0.2; logoutChance: Double = 0.33);
 var
-  len: Integer;
+  idx: Integer;
 begin
-  len := System.Length(Self.Breaks);
-  SetLength(Self.Breaks, len+1);
-  Self._UpdateBreak(len, interval, length, randomness, logoutChance);
+  idx := System.Length(Self.Breaks);
+  SetLength(Self.Breaks, idx+1);
+  Self._UpdateBreak(idx, interval, length, randomness, logoutChance);
 end;
 
 (*
@@ -203,7 +247,8 @@ In other words, you will never sleep before `time`.
 `logoutChance` is the probability of logging out for the sleep break or to
 simply afk and logout from inactivity.
 
-This sleep break will only occur when {ref}`Antiban.DoAntiban` is called and our sleep break is due.
+This sleep break will only occur when {ref}`Antiban.DoAntiban` is called and our
+sleep break is due.
 
 Example:
 ```pascal
@@ -212,11 +257,43 @@ Antiban.AddSleep('01:30:45', 8 * ONE_HOUR, 0.1, 0.8); //At 01:30:45 on our compu
 *)
 procedure TAntiban.AddSleep(time: String; length: Double; randomness: Double = 0.1; logoutChance: Double = 0.5);
 var
-  len: Integer;
+  idx: Integer;
 begin
-  len := System.Length(Self.Sleeps);
-  SetLength(Self.Sleeps, len+1);
-  Self._UpdateSleep(len, time, length, randomness, logoutChance);
+  idx := System.Length(Self.Sleeps);
+  SetLength(Self.Sleeps, idx+1);
+  Self._UpdateSleep(idx, time, length, randomness, logoutChance);
+end;
+
+(*
+## Antiban.AddWalkTask
+```pascal
+procedure TAntiban.AddWalkTask(method: TAntibanMethod; interval: Double; randomness: Double = 0.2);
+```
+Schedule a walking antiban task.
+An antiban task can be any procedure but they should be short actions that won't
+break your main script.
+
+`method` is a pointer to the task you want to perform.
+WaspLib includes a couple of them but you may make your own if you want.
+
+`interval` is the aproximate interval of time that has to pass for the antiban
+task to occur and it will be repeated everytime that the interval has passed
+and the antiban is checked with {ref}`Antiban.DoAntiban`.
+
+This task will only occur when **TAntiban.DoAntiban** is called.
+
+Example:
+```pascal
+Antiban.AddWalkTask(@Antiban.HoverSkills, 15 * ONE_MINUTE); //Every 15 minutes the script will run Antiban.HoverSkills().
+```
+*)
+procedure TAntiban.AddWalkTask(method: TAntibanMethod; interval: Double; randomness: Double = 0.2);
+var
+  idx: Integer;
+begin
+  idx := Length(Self.WalkTasks);
+  SetLength(Self.WalkTasks, idx+1);
+  Self._UpdateWalkTask(idx, @method, interval, randomness);
 end;
 
 
@@ -416,7 +493,7 @@ function TAntiban.DoTask(): Boolean;
 ```
 Checks for scheduled antiban tasks, if any is due it will do it.
 
-You should only call this when taking doing an antiban task won't break your script.
+You should only call this when doing an antiban task won't break your script.
 
 Returns true if a task was performed.
 
@@ -427,36 +504,40 @@ Antiban.DoTask();
 *)
 function TAntiban.DoTask(): Boolean;
 var
-  i: Int32;
+  i: Integer;
   task: PAntibanTask;
-  activeTasks: PAntibanTaskArray;
+  active: PAntibanTaskArray;
 begin
-  activeTasks := Self.GetActiveTasks();
-  for i := 0 to High(activeTasks) do
-    activeTasks[i]^.Countdown.Pause();
+  active := Self.GetActiveTasks();
+  for i := 0 to High(active) do
+    active[i]^.Countdown.Pause();
 
-  for i := 0 to High(activeTasks) do
+  for i := 0 to High(active) do
   begin
-    task := activeTasks[i];
+    task := active[i];
 
-    if task^.Countdown.Remaining = 0 then
-    begin
-      if (@Self.OnStartTask <> nil) then
-        Self.OnStartTask(Task);
+    if task^.Countdown.Remaining <> 0 then
+      Continue;
 
-      task^.Method();
-      task^.Countdown.Start(Trunc(Abs(GaussRand(task^.Interval, task^.Interval * task^.StdVar))));
-      task^.Countdown.Pause();
+    if @Self.OnStartTask <> nil then
+      Self.OnStartTask(Task);
 
-      if (@Self.OnFinishTask <> nil) then
-        Self.OnFinishTask(Task);
+    task^.Method();
+    task^.Countdown.Start(
+      Trunc(Abs(GaussRand(
+        task^.Interval, task^.Interval * task^.StdVar
+      )))
+    );
+    task^.Countdown.Pause();
 
-      Result := True;
-    end;
+    if @Self.OnFinishTask <> nil then
+      Self.OnFinishTask(Task);
+
+    Result := True;
   end;
 
-  for i := 0 to High(activeTasks) do
-    activeTasks[i]^.Countdown.Resume();
+  for i := 0 to High(active) do
+    active[i]^.Countdown.Resume();
 end;
 
 (*
@@ -525,6 +606,61 @@ begin
     end;
 end;
 
+(*
+## Antiban.DoWalkTask
+```pascal
+function TAntiban.DoWalkTask(): Boolean;
+```
+Checks for scheduled walking antiban tasks, if any is due it will do it.
+
+You should only call this when walking and doing an antiban task won't break
+your script.
+
+Returns true if a task was performed.
+
+Example:
+```pascal
+Antiban.DoWalkTask();
+```
+*)
+function TAntiban.DoWalkTask(): Boolean;
+var
+  i: Integer;
+  task: PAntibanTask;
+  active: PAntibanTaskArray;
+begin
+  active := Self.GetActiveWalkTasks();
+  for i := 0 to High(active) do
+    active[i]^.Countdown.Pause();
+
+  for i := 0 to High(active) do
+  begin
+    task := active[i];
+
+    if task^.Countdown.Remaining <> 0 then
+      Continue;
+
+    if @Self.OnStartTask <> nil then
+      Self.OnStartTask(Task);
+
+    task^.Method();
+    task^.Countdown.Start(
+      Trunc(Abs(GaussRand(
+        task^.Interval, task^.Interval * task^.StdVar
+      )))
+    );
+    task^.Countdown.Pause();
+
+    if @Self.OnFinishTask <> nil then
+      Self.OnFinishTask(Task);
+
+    Result := True;
+  end;
+
+  for i := 0 to High(active) do
+    active[i]^.Countdown.Resume();
+end;
+
 
 (*
 ## Antiban.DoAntiban
@@ -576,6 +712,33 @@ begin
   Self.TimeRunning.Pause();
 end;
 
+(*
+## Antiban.DoWalkingAntiban
+```pascal
+function TAntiban.DoWalkingAntiban(): Boolean;
+```
+This should be called in your script when walking and walking tasks won't break
+your script.
+
+When this is called, the setup walking tasks will be checked, if enough time has
+passed to perform any of them, they will be performed, otherwise,
+nothing will happen.
+*)
+function TAntiban.DoWalkingAntiban(): Boolean;
+begin
+  if Self.DoingAntiban then
+    Exit;
+
+  Self.DoingAntiban := True;
+  Self.TimeRunning.Resume();
+
+  if Self.DoWalkTask() then
+    Result := True;
+
+  Self.DoingAntiban := False;
+  Self.TimeRunning.Pause();
+end;
+
 
 (*
 ## Antiban.TimeUntilBreak
@@ -650,12 +813,6 @@ begin
   WriteLn('Running for ', FormatMilliseconds(Round(active), TIME_FORMAL), ' per day, on average.');
 end;
 
-
-procedure TAntiban.WalkingTasks();
-begin
-  //overriden later.
-end;
-
 var
 (*
 ## Antiban variable