fix: more work on opening doors

Author: Torwent

osrs/walker.simba

@@ -256,6 +256,45 @@ begin
   Result := [arr[0], arr[1], arr[2], arr[3]];
 end;
 
+function TRSWalker.GetCuboidMS(me, mapPoint: TPoint; size: TVector3; radians: Single = $FFFF): TCuboid;
+var
+  vector: TVector2;
+  corners: TVector3Array;
+  h: Single;
+  pt, currLoc: TPoint;
+  arr: TPointArray;
+begin
+  if not me.InRange(mapPoint, MM2MS.MAX_RENDER_DISTANCE) then Exit;
+  if radians = $FFFF then radians := Minimap.GetCompassAngle(False);
+  vector := Self.Point2MMVec(me, mapPoint, radians);
+  pt := vector.ToPoint();
+
+  vector := Minimap.NormalizeEx(vector, radians);
+  me := Self.GetLocal(me);
+
+  h := Self.Height(me - [1,3], False) + Self.Height(me + [3,-3], False) +
+       Self.Height(me + [3,1], False) + Self.Height(me - [1,1], False);
+  h := h/4;
+
+  currLoc := me + vector.ToPoint() - Minimap.Center;
+
+  corners := [
+    [vector.X-size.X, vector.Y-size.Y, Self.Height(currLoc - [1,3],  False) - h],
+    [vector.X+size.X, vector.Y-size.Y, Self.Height(currLoc + [3,-3], False) - h],
+    [vector.X+size.X, vector.Y+size.Y, Self.Height(currLoc + [3,1],  False) - h],
+    [vector.X-size.X, vector.Y+size.Y, Self.Height(currLoc - [1,1],  False) - h],
+    [vector.X-size.X, vector.Y-size.Y, Self.Height(currLoc - [1,3],  False) - h+size.Z],
+    [vector.X+size.X, vector.Y-size.Y, Self.Height(currLoc + [3,-3], False) - h+size.Z],
+    [vector.X+size.X, vector.Y+size.Y, Self.Height(currLoc + [3,1],  False) - h+size.Z],
+    [vector.X-size.X, vector.Y+size.Y, Self.Height(currLoc - [1,1],  False) - h+size.Z]
+  ];
+
+  arr := MM2MS.Run(corners, radians);
+  Result := [
+    [arr[4], arr[5], arr[6], arr[7]], [arr[0], arr[1], arr[2], arr[3]]
+  ];
+end;
+
 function TRSWalker.MM2Map(me, minimapPoint: TPoint; radians: Single = $FFFF): TPoint;
 begin
   Result := me + minimapPoint - Minimap.Center;
@@ -265,22 +304,34 @@ begin
 end;
 
 
-procedure TRSWalker.SetFlag(me: TPoint; radians: Single = $FFFF);
+function TRSWalker.FindFlag(me: TPoint; out flag: TPoint; radians: Single = $FFFF): Boolean;
+begin
+  Result := Minimap.FindFlag(flag);
+  if Result then
+    flag := Self.MM2Map(me, flag, radians);
+end;
+
+function TRSWalker.WaitFlag(out flag: TPoint; radians: Single = $FFFF): Boolean;
 begin
-  if Minimap.FindFlag(Self._Flag) then
-    Self._Flag := Self.MM2Map(me, Self._Flag, radians);
+  Result := SleepUntil(Self.FindFlag(Self.Position(), flag, radians), 100, 600);
 end;
 
-function TRSWalker.FlagMoved(me: TPoint; radians: Single = $FFFF): Boolean;
+function TRSWalker.FlagMoved(out flag: TPoint; radians: Single = $FFFF): Boolean;
 var
-  pt: TPoint;
+  newFlag: TPoint;
 begin
-  pt := Self._Flag;
-  Self.SetFlag(me, radians);
-  if not pt.InRange(Self._Flag, 3) then
-    Exit(True);
+
+  Result := SleepUntil(
+              Self.FindFlag(Self.Position(), newFlag, radians) and not newFlag.InRange(flag, 4),
+              100,
+              600
+            );
+
+  flag := newFlag;
 end;
 
+
+
 (*
 ## TRSWalker.InRange
 ```pascal
@@ -460,7 +511,7 @@ begin
     if position.Current <> position.Previous then
       countdown.Restart();
 
-    if (Self._Node <> EGraphNode.NORMAL) and Self.FlagMoved(position.Current, Minimap.GetCompassAngle(False)) then
+    //if (Self._Node <> EGraphNode.NORMAL) and Self.FlagMoved(position.Current, Minimap.GetCompassAngle(False)) then
     begin
       Self.Walking := False;
       Break;
@@ -552,7 +603,6 @@ begin
         Self.RedClicked := ChooseOption.Select(Self.ActionUpText);
         if Self.RedClicked then
           Self.Walking := False;
-        Self.SetFlag(me, Minimap.GetCompassAngle(False));
         Exit(Self.RedClicked);
       end;
     end
@@ -584,26 +634,25 @@ begin
 
   if Self.RedClicked then
     Self.Walking := False;
-  Self.SetFlag(me, Minimap.GetCompassAngle(False));
 end;
 
 (*
 ## Walker.IsWalkable
 ```pascal
-function TRSWalker.IsWalkable(mapPoint: TPoint; me: TPoint; out mmPoint: TPoint; angle: Double): Boolean;
+function TRSWalker.IsWalkable(mapPoint: TPoint; me: TPoint; out mmPoint: TPoint; radians: Double): Boolean;
 ```
 Internal method used by walker to decide if the destination point is within 1 click reach.
 You will probably never need to call this directly.
 *)
-function TRSWalker.IsWalkable(mapPoint, me: TPoint; out mmPoint: TPoint; angle: Double): Boolean;
+function TRSWalker.IsWalkable(mapPoint, me: TPoint; out mmPoint: TPoint; radians: Double): Boolean;
 var
   corner: TPoint;
 begin
-  mmPoint := Self.Point2MM(me, mapPoint, angle);
+  mmPoint := Self.Point2MM(me, mapPoint, radians);
   if not Self.ScreenWalk then
     Exit(Minimap.Polygon.Expand(-1).Contains(mmPoint));
 
-  for corner in Self.GetQuadMS(me, mapPoint, angle).Expand(-8).Corners do
+  for corner in Self.GetQuadMS(me, mapPoint, radians).Expand(-8).Corners do
     if MainScreen.Bounds.Contains(corner) then
       Exit(True);
 end;
@@ -668,27 +717,65 @@ begin
     Result := Self.Position().InRange(mapPt, Max(minDist, 3));
 end;
 
-function TRSWalker.CrossDoor(me: TPoint; index: Integer): Boolean;
+function TRSWalker.CrossDoor(me: TPoint; index: Integer; attempts: Integer = 3): Boolean;
 var
   tmp: TPoint;
   door, furthest: Integer;
-  angle: Double;
+  radians: Double;
+  mapPt, minimapPt, flag: TPoint;
+  shouldExit, handleDoor: Boolean;
+  cuboid: TCuboid;
 begin
+  WriteLn GetDebugLn(Self.Name, 'Attempting to cross door');
+  if attempts = 0 then Exit;
+
   if index = High(Self._Path) then
     raise GetDebugLn(Self.Name, 'Paths should not end at a door node.');
 
   door := Self._Path.IndexOf(Self._Path[index].Node);
   furthest := door;
 
-  angle := Minimap.GetCompassAngle(False);
-  while (furthest < High(Self._Path)) and Self.IsWalkable(Self._Path[furthest+1].Node, me, tmp, angle) do
+  radians := Minimap.GetCompassAngle(False);
+  while (furthest < High(Self._Path)) and Self.IsWalkable(Self._Path[furthest+1].Node, me, tmp, radians) do
     if Self._Path[furthest+1].Typ = EGraphNode.NORMAL then
       Inc(furthest);
 
   if Biometrics.RandomBoolean(0.002) then
     furthest := Random(door, furthest);
 
-  //TODO: ... Handle door
+  mapPt := Self._Path[furthest].Node;
+  if not Self._WalkStepHelper(me, mapPt, 0, minimapPt, shouldExit) then
+    Exit;
+
+  if shouldExit then Exit;
+
+  if Self.WaitFlag(flag) then
+    handleDoor := Self.FlagMoved(flag, radians)
+  else
+    handleDoor := True;
+
+  if not handleDoor then
+  begin
+    Self.WaitMoving(mapPt, 4);
+    if not Self.WebGraph^.WalkableClusters.InSameTPA(Self.Position(), mapPt) then
+      handleDoor := True;
+  end;
+
+  me := Self.Position();
+
+  if handleDoor then
+  begin
+    WriteLn GetDebugLn(Self.Name, 'Attempting to open door');
+    cuboid := Self.GetCuboidMS(me, Self._Path[door].Node, [0.6,0.6,4], radians);
+    ShowOnTarget(cuboid);
+    Mouse.Move(cuboid.ShapeFill().RandomMean());
+    if MainScreen.IsUpText('Open') then
+      Mouse.Click(EMouseButton.LEFT)
+    else if not ChooseOption.Select('Open') then
+      Exit;
+  end;
+
+  Result := Self.CrossDoor(me, index, Dec(attempts));
 end;
 
 function TRSWalker.UseStairs(me: TPoint; index: Integer): Boolean;