Exemple #1
0
        private void FindObjectiveMarker()
        {
            // Get Special objective Marker
            _miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                             .Where(m => m.IsPointOfInterest && m.Id < 1000)
                             .OrderBy(m => m.Position.Distance2DSqr(ZetaDia.Me.Position)).FirstOrDefault();

            if (_miniMapMarker == null)
            {
                // Get point of interest marker
                _miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                                 .Where(m => m.IsPointOfInterest)
                                 .OrderBy(m => m.Position.Distance2DSqr(ZetaDia.Me.Position)).FirstOrDefault();
            }

            if (_miniMapMarker != null)
            {
                Logger.Log("Using Objective Style Minimap Marker: {0} dist: {1:0} isExit: {2} isEntrance {3}",
                           _miniMapMarker.NameHash,
                           _miniMapMarker.Position.Distance2D(ZetaDia.Me.Position),
                           _miniMapMarker.IsPortalExit,
                           _miniMapMarker.IsPortalEntrance);
            }

            if (_miniMapMarker != null && _miniMapMarker.Position != Vector3.Zero)
            {
                _mapMarkerLastPosition = _miniMapMarker.Position;
            }
        }
Exemple #2
0
 private string ReturnMinimapMarkerString(MinimapMarker mmm)
 {
     return(String.Format("ID: {0} DynamicWorldId: {1} NameHash: {2} Position: {3}\r\n" +
                          "IsPointOfInterest:{4} IsPortalEntrance:{5} IsPortalExit:{6} IsWaypoint:{7}",
                          mmm.Id, mmm.DynamicWorldId, String.Format("{0:X}", mmm.NameHash), mmm.Position,
                          mmm.IsPointOfInterest, mmm.IsPortalEntrance, mmm.IsPortalExit, mmm.IsWaypoint));
 }
Exemple #3
0
 private TrinityMarker Create(int key, MinimapMarker newItem, out bool success)
 {
     success = true;
     return(new TrinityMarker
     {
         Id = newItem.Id,
         NameHash = newItem.NameHash,
         WorldSnoId = newItem.WorldId,
         Position = newItem.Position,
         Distance = newItem.Distance,
         TextureId = newItem.MinimapTextureSnoId,
         MarkerType = newItem.MarkerType,
     });
 }
Exemple #4
0
        private void FindMiniMapMarker()
        {
            // find our map marker
            if (miniMapMarker == null)
            {
                //miniMapMarker = ZetaDia.Minimap.CurrentWorldMarkers.Where(o => o != null && o.NameHash == MapMarkerNameHash).OrderBy(o => o.Position.Distance(ZetaDia.Me.Position)).FirstOrDefault();
                miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                                .Where(o => o != null && o.NameHash == MapMarkerNameHash)
                                .OrderBy(o => o.Position.Distance(ZetaDia.Me.Position)).FirstOrDefault();

                if (miniMapMarker != null && miniMapMarker.Position != Vector3.Zero)
                {
                    mapMarkerLastPosition = miniMapMarker.Position;
                }
            }
        }
Exemple #5
0
        public override void ResetCachedDone()
        {
            _isDone = false;

            _behaviorStartTime         = DateTime.UtcNow;
            _lastPosition              = Vector3.Zero;
            _stuckStart                = DateTime.UtcNow;
            _lastCheckedStuck          = DateTime.UtcNow;
            _lastMoveResult            = MoveResult.Moved;
            _completedInteractAttempts = 0;
            _startWorldId              = ZetaDia.CurrentWorldId;
            _miniMapMarker             = null;
            _mapMarkerLastPosition     = Vector3.Zero;
            _interactObject            = null;

            base.ResetCachedDone();
        }
Exemple #6
0
        private TrinityMarker Create(int key, MinimapMarker newItem, out bool success)
        {
            var nativeMarker = (Marker)newItem;

            success = true;
            return(new TrinityMarker
            {
                Name = nativeMarker.Name,
                Id = nativeMarker.Id,
                NameHash = nativeMarker.NameHash,
                WorldSnoId = nativeMarker.WorldId,
                Position = nativeMarker.Position,
                Distance = nativeMarker.Distance,
                TextureId = nativeMarker.MinimapTextureId,
                MarkerType = nativeMarker.MarkerType,
            });
        }
Exemple #7
0
        public override void OnStart()
        {
            // set defaults
            if (Math.Abs(PathPrecision) < 1f)
            {
                PathPrecision = 20;
            }
            if (PathPointLimit == 0)
            {
                PathPointLimit = 250;
            }
            if (Math.Abs(InteractRange) < 1f)
            {
                InteractRange = 10;
            }
            if (InteractAttempts == 0)
            {
                InteractAttempts = 5;
            }
            if (TimeoutSeconds == 0)
            {
                TimeoutSeconds = TimeoutSecondsDefault;
            }
            if (MaxSearchDistance <= 0)
            {
                MaxSearchDistance = 10;
            }

            _behaviorStartTime         = DateTime.UtcNow;
            _lastPosition              = Vector3.Zero;
            _stuckStart                = DateTime.UtcNow;
            _lastCheckedStuck          = DateTime.UtcNow;
            _lastMoveResult            = MoveResult.Moved;
            _completedInteractAttempts = 0;
            _startWorldId              = ZetaDia.CurrentWorldId;
            _miniMapMarker             = null;
            _mapMarkerLastPosition     = Vector3.Zero;
            _interactObject            = null;

            Navigator.Clear();
            Logger.Debug("Initialized {0}", Status());
        }
Exemple #8
0
        private void FindMiniMapMarker()
        {
            // Special condition for Rift portals
            if (DataDictionary.RiftWorldIds.Contains(ZetaDia.CurrentWorldId) && Position == Vector3.Zero && ActorId == 0 && IsPortal && DestinationWorldId == -1)
            {
                _miniMapMarker = GetRiftExitMarker();
                if (_miniMapMarker != null)
                {
                    MapMarkerNameHash = _miniMapMarker.NameHash;
                    Logger.Log("Using Rift Style Minimap Marker: {0} dist: {1:0} isExit: {2}",
                               _miniMapMarker.NameHash,
                               _miniMapMarker.Position.Distance2D(ZetaDia.Me.Position),
                               _miniMapMarker.IsPortalExit);
                }
            }

            // find our map marker
            if (_miniMapMarker == null)
            {
                if (Position != Vector3.Zero)
                {
                    _miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                                     .Where(marker => marker != null && marker.NameHash == MapMarkerNameHash &&
                                            Position.Distance(marker.Position) < MaxSearchDistance)
                                     .OrderBy(o => o.Position.Distance(ZetaDia.Me.Position)).FirstOrDefault();
                }
                else
                {
                    _miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                                     .Where(marker => marker != null && marker.NameHash == MapMarkerNameHash)
                                     .OrderBy(o => o.Position.Distance(ZetaDia.Me.Position)).FirstOrDefault();
                }
            }
            if (_miniMapMarker != null && _miniMapMarker.Position != Vector3.Zero)
            {
                _mapMarkerLastPosition = _miniMapMarker.Position;
            }
        }
        static MinimapSpecification DeepClone(MinimapSpecification spec)
        {
            var clone = new MinimapSpecification();

            foreach (var area in spec.Areas)
            {
                var cloneArea = new MinimapArea
                {
                    DefaultColor = area.DefaultColor,
                    LevelID      = area.LevelID
                };

                foreach (var room in area.Rooms)
                {
                    var cloneRoom = new MinimapRoom(cloneArea)
                    {
                        IsDebug      = room.IsDebug,
                        DefaultColor = room.DefaultColor,
                        RoomID       = room.RoomID,
                        Width        = room.Width,
                        Height       = room.Height,
                        Position     = room.Position
                    };

                    foreach (var kvp in room.Blocks)
                    {
                        var point = kvp.Key;
                        var block = kvp.Value;

                        var cloneBlock = new MinimapBlock(cloneRoom)
                        {
                            IsKnown          = block.IsKnown,
                            IsVisited        = block.IsVisited,
                            IsBoss           = block.IsBoss,
                            IsTimespinner    = block.IsTimespinner,
                            IsTransition     = block.IsTransition,
                            IsCheckpoint     = block.IsCheckpoint,
                            IsSolidWall      = block.IsSolidWall,
                            HasSolidWallToNW = block.HasSolidWallToNW,
                            RoomColor        = block.RoomColor,
                            Position         = block.Position
                        };

                        var dynamicCloneBlock = cloneBlock.AsDynamic();

                        dynamicCloneBlock._walls       = block.Walls;
                        dynamicCloneBlock._doors       = block.Doors;
                        dynamicCloneBlock._secretDoors = block.SecretDoors;

                        cloneRoom.Blocks.Add(point, cloneBlock);
                    }

                    cloneArea.Rooms.Add(cloneRoom);
                }

                clone.Areas.Add(cloneArea);
            }

            foreach (var kvp in spec.Markers)
            {
                var point  = kvp.Key;
                var marker = kvp.Value;

                var cloneMarker = new MinimapMarker
                {
                    IsVisible            = marker.IsVisible,
                    EraColor             = marker.EraColor,
                    MarkerColor          = marker.MarkerColor,
                    Location             = marker.Location,
                    DrawLocationPosition = marker.DrawLocationPosition
                };

                clone.Markers.Add(point, cloneMarker);
            }

            foreach (var revealGroup in spec.RevealGroups)
            {
                var cloneRevealGroup = new MinimapRevealGroup
                {
                    ID = revealGroup.ID
                };

                var cloneRoomList = (List <int>)cloneRevealGroup.AsDynamic()._rooms;
                foreach (var room in revealGroup.Rooms)
                {
                    cloneRoomList.Add(room);
                }

                clone.RevealGroups.Add(cloneRevealGroup);
            }

            clone.PopulateAllBlocks();

            return(clone);
        }
    //Creates an icon that will represent the given target object on the minimap
    //Note: This marker object should only be seen by the minimap camera; turn off the Minimap Marker layer on other cameras.
    private void AddMinimapMarker(Transform _targetObj, MinimapMarker _markerType)
    {
        GameObject minimapMarker;

        //Temp marker type check. Will need to be modified as more marker types are accomodated.
        if (!(_markerType == MinimapMarker.PLAYER || _markerType == MinimapMarker.ENEMY))
        {
            Debug.LogError("[Error] Invalid minimap marker type; Aborting operation...");
            return;
        }

        minimapMarker       = GameObject.CreatePrimitive(PrimitiveType.Quad);
        minimapMarker.name  = "Minimap Icon";
        minimapMarker.layer = LayerMask.NameToLayer("Minimap Marker");
        minimapMarker.GetComponent <MeshRenderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
        minimapMarker.GetComponent <MeshRenderer>().receiveShadows    = false;
        Destroy(minimapMarker.GetComponent <MeshCollider>());

        minimapMarker.transform.SetParent(_targetObj);
        minimapMarker.transform.localPosition = new Vector3(0, iconOverheadHeight, 0);
        //minimapMarker.transform.position = new Vector3(0, transform.parent.position.y + iconOverheadHeight, 0);
        minimapMarker.transform.localEulerAngles = new Vector3(90, 0, 0);
        minimapMarker.transform.localScale       = new Vector3(miniMapIconSizes, miniMapIconSizes, 1);

        switch (_markerType)
        {
        case MinimapMarker.NONE:
            return;

        case MinimapMarker.PLAYER:
            if (playerMinimapMarkerRef)
            {
                minimapMarker.GetComponent <MeshRenderer>().material = playerMinimapMarkerRef;

                //Custom settings
                minimapMarker.transform.localScale = new Vector3(playerIconSize, playerIconSize, 1);
                if (playerIconYRotation != 0)
                {
                    minimapMarker.transform.localEulerAngles = new Vector3(90, playerIconYRotation, 0);
                }
            }
            else
            {
                Debug.LogError("[Error] Player minimap marker material reference missing!");
            }
            break;

        case MinimapMarker.ENEMY:
            if (enemyMinimapMarkerRef)
            {
                minimapMarker.GetComponent <MeshRenderer>().material = enemyMinimapMarkerRef;
            }
            else
            {
                Debug.LogError("[Error] Enemy minimap marker material reference missing!");
            }
            break;

        default:
            return;
        }
    }
Exemple #11
0
 private TrinityMarker Update(int key, TrinityMarker existingItem, MinimapMarker newItem, out bool success)
 {
     success = existingItem.WorldSnoId == Core.Player.WorldDynamicId;
     existingItem.Distance = Core.Player.Position.Distance(existingItem.Position);
     return(existingItem);
 }
Exemple #12
0
    //Creates an icon that will represent the given target object on the minimap
    //Note: This marker object should only be seen by the minimap camera; turn off the Minimap Marker layer on other cameras.
    private void AddMinimapMarker(Transform _targetObj, MinimapMarker _markerType)
    {
        GameObject minimapMarker;

        //Temp marker type check. Will need to be modified as more marker types are accomodated.
        if (!(_markerType == MinimapMarker.PLAYER || _markerType == MinimapMarker.ENEMY ||
              _markerType == MinimapMarker.PICKUP || _markerType == MinimapMarker.CHECKPOINT ||
              _markerType == MinimapMarker.OBJECTIVE))
        {
            Debug.LogError("[Error] Invalid minimap marker type; Aborting operation...");
            return;
        }

        minimapMarker       = new GameObject();
        minimapMarker.name  = "Minimap Icon";
        minimapMarker.layer = LayerMask.NameToLayer("Minimap Marker");
        minimapMarker.AddComponent <SpriteRenderer>();

        switch (_markerType)
        {
        case MinimapMarker.NONE:
            return;

        case MinimapMarker.PLAYER:
            if (playerMinimapMarkerSprite)
            {
                minimapMarker.transform.localScale       = new Vector3(miniMapIconSizes, miniMapIconSizes, 1);
                minimapMarker.transform.position         = new Vector3(_targetObj.position.x, _targetObj.position.y + iconOverheadHeight, _targetObj.position.z);
                minimapMarker.transform.localEulerAngles = new Vector3(90, _targetObj.localEulerAngles.y, _targetObj.localEulerAngles.z);
                minimapMarker.transform.SetParent(_targetObj);
                minimapMarker.GetComponent <SpriteRenderer>().sprite = playerMinimapMarkerSprite;

                //Custom settings
                //minimapMarker.transform.localScale = new Vector3(playerIconSize, playerIconSize, 1);
                if (playerIconYRotation != 0)
                {
                    minimapMarker.transform.localEulerAngles = new Vector3(90, playerIconYRotation, 0);
                }
            }
            else
            {
                Debug.LogError("[Error] Player minimap marker material reference missing!");
            }
            break;

        case MinimapMarker.ENEMY:
            if (enemyMinimapMarkerSprite)
            {
                minimapMarker.transform.localScale       = new Vector3(miniMapIconSizes, miniMapIconSizes, 1);
                minimapMarker.transform.position         = new Vector3(_targetObj.position.x, _targetObj.position.y + iconOverheadHeight - 1, _targetObj.position.z);
                minimapMarker.transform.localEulerAngles = new Vector3(90, _targetObj.localEulerAngles.y, _targetObj.localEulerAngles.z);
                minimapMarker.transform.SetParent(_targetObj);
                minimapMarker.GetComponent <SpriteRenderer>().sprite = enemyMinimapMarkerSprite;
            }
            else
            {
                Debug.LogError("[Error] Enemy minimap marker material reference missing!");
            }
            break;

        case MinimapMarker.PICKUP:
            if (pickupMinimapMarkerSprite)
            {
                minimapMarker.transform.localScale       = new Vector3(miniMapIconSizes * 0.8f, miniMapIconSizes * 0.8f, 1);
                minimapMarker.transform.position         = new Vector3(_targetObj.position.x, _targetObj.position.y + iconOverheadHeight - 2, _targetObj.position.z);
                minimapMarker.transform.localEulerAngles = new Vector3(90, 0, 0);
                minimapMarker.transform.SetParent(_targetObj);
                minimapMarker.GetComponent <SpriteRenderer>().sprite = pickupMinimapMarkerSprite;
            }
            else
            {
                Debug.LogError("[Error] Pickup minimap marker material reference missing!");
            }
            break;

        case MinimapMarker.CHECKPOINT:
            if (checkpointMinimapMarkerSprite)
            {
                minimapMarker.transform.localScale       = new Vector3(miniMapIconSizes, miniMapIconSizes, 1);
                minimapMarker.transform.position         = new Vector3(_targetObj.position.x, _targetObj.position.y + iconOverheadHeight - 2, _targetObj.position.z);
                minimapMarker.transform.localEulerAngles = new Vector3(90, 0, 0);
                minimapMarker.transform.SetParent(_targetObj);
                minimapMarker.GetComponent <SpriteRenderer>().sprite = checkpointMinimapMarkerSprite;
            }
            else
            {
                Debug.LogError("[Error] Checkpoint minimap marker material reference missing!");
            }
            break;

        case MinimapMarker.OBJECTIVE:
            if (objectiveMinimapMarkerSprite)
            {
                minimapMarker.transform.localScale       = new Vector3(miniMapIconSizes, miniMapIconSizes, 1);
                minimapMarker.transform.position         = new Vector3(_targetObj.position.x, _targetObj.position.y + iconOverheadHeight - 2, _targetObj.position.z);
                minimapMarker.transform.localEulerAngles = new Vector3(90, 0, 0);
                minimapMarker.transform.SetParent(_targetObj);
                minimapMarker.GetComponent <SpriteRenderer>().sprite = objectiveMinimapMarkerSprite;
            }
            else
            {
                Debug.LogError("[Error] Objective minimap marker material reference missing!");
            }
            break;

        default:
            Debug.LogError("[Error] Invalid minimap marker type; Aborting operation...");
            return;
        }
    }
Exemple #13
0
 private int GetKey(MinimapMarker item) => item.Id;
Exemple #14
0
        private static void btnMoveToMapMarker_Click(object sender, RoutedEventArgs e)
        {
            if (BotMain.IsRunning)
            {
                BotMain.Stop();
            }

            Thread.Sleep(500);
            try
            {
                using (new ZetaCacheHelper())
                {
                    if (!ZetaDia.IsInGame)
                    {
                        return;
                    }
                    if (ZetaDia.Me == null)
                    {
                        return;
                    }
                    if (!ZetaDia.Me.IsValid)
                    {
                        return;
                    }

                    ZetaDia.Actors.Update();

                    MinimapMarker marker = ZetaDia.Minimap.Markers.CurrentWorldMarkers.OrderBy(m => m.Position.Distance2D(ZetaDia.Me.Position)).FirstOrDefault();

                    if (marker == null)
                    {
                        return;
                    }

                    DiaObject portal = (from o in ZetaDia.Actors.GetActorsOfType <GizmoPortal>(true)
                                        orderby o.Position.Distance(ZetaDia.Me.Position)
                                        select o).FirstOrDefault() ??
                                       (from o in ZetaDia.Actors.GetActorsOfType <DiaObject>(true)
                                        orderby o.Position.Distance(marker.Position)
                                        select o).FirstOrDefault();

                    string questInfo;
                    string questHeader;
                    GetQuestInfoText(out questInfo, out questHeader);

                    string locationInfo = "";

                    if (!ZetaDia.WorldInfo.IsGenerated)
                    {
                        locationInfo = string.Format("x=\"{0:0}\" y=\"{1:0}\" z=\"{2:0}\" ",
                                                     portal.Position.X, portal.Position.Y, portal.Position.Z);
                    }

                    if (portal != null)
                    {
                        string tagText = string.Format(questHeader + "\n<MoveToMapMarker " + questInfo + " " + locationInfo + "markerNameHash=\"{0}\" actorId=\"{1}\" interactRange=\"{2}\" \n" +
                                                       Indent3Hang + "pathPrecision=\"5\" pathPointLimit=\"250\" isPortal=\"True\" destinationWorldId=\"-1\" statusText=\"\" /> \n",
                                                       marker.NameHash, portal.ActorSNO, portal.CollisionSphere.Radius);
                        Clipboard.SetText(tagText);
                        Logger.Log(tagText);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Log(ex.ToString());
            }
        }
        public override void OnStart()
        {
            // set defaults
            if (Math.Abs(PathPrecision) < 1f)
                PathPrecision = 20;
            if (PathPointLimit == 0)
                PathPointLimit = 250;
            if (Math.Abs(InteractRange) < 1f)
                InteractRange = 10;
            if (InteractAttempts == 0)
                InteractAttempts = 5;
            if (TimeoutSeconds == 0)
                TimeoutSeconds = TimeoutSecondsDefault;
            if (MaxSearchDistance <= 0)
                MaxSearchDistance = 10;

            _behaviorStartTime = DateTime.UtcNow;
            _lastPosition = Vector3.Zero;
            _stuckStart = DateTime.UtcNow;
            _lastCheckedStuck = DateTime.UtcNow;
            _lastMoveResult = MoveResult.Moved;
            _completedInteractAttempts = 0;
            _startWorldId = ZetaDia.CurrentWorldId;
            _miniMapMarker = null;
            _mapMarkerLastPosition = Vector3.Zero;
            _interactObject = null;

            Navigator.Clear();
            Logger.Debug("Initialized {0}", Status());
        }
        /// <summary>
        /// Finds the objective marker.
        /// </summary>
        private void FindObjectiveMarker()
        {
            // Get Special objective Marker
            _miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                .Where(m => m.IsPointOfInterest && m.Id < 1500)
                .OrderBy(m => m.Position.Distance2DSqr(ZetaDia.Me.Position)).FirstOrDefault();

            if (_miniMapMarker == null)
            {
                // Get point of interest marker
                _miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                .Where(m => m.IsPointOfInterest)
                .OrderBy(m => m.Position.Distance2DSqr(ZetaDia.Me.Position)).FirstOrDefault();
            }

            if (_miniMapMarker != null)
            {
                Logger.Log("Found Objective Minimap Marker: {0} dist: {1:0} isExit: {2} isEntrance {3}",
                    _miniMapMarker.NameHash,
                    _miniMapMarker.Position.Distance2D(ZetaDia.Me.Position),
                    _miniMapMarker.IsPortalExit,
                    _miniMapMarker.IsPortalEntrance);
            }

            if (_miniMapMarker != null && _miniMapMarker.Position != Vector3.Zero)
            {
                _mapMarkerLastPosition = _miniMapMarker.Position;
            }

        }
        private void FindMiniMapMarker()
        {
            // Special condition for Rift portals
            if (DataDictionary.RiftWorldIds.Contains(ZetaDia.CurrentWorldId) && Position == Vector3.Zero && ActorId == 0 && IsPortal && DestinationWorldId == -1)
            {
                _miniMapMarker = GetRiftExitMarker();
                if (_miniMapMarker != null)
                {
                    MapMarkerNameHash = _miniMapMarker.NameHash;
                    Logger.Debug("Using Rift Style Minimap Marker: {0} dist: {1:0} isExit: {2}",
                        _miniMapMarker.NameHash,
                        _miniMapMarker.Position.Distance2D(ZetaDia.Me.Position),
                        _miniMapMarker.IsPortalExit);
                }
            }

            // find our map marker
            if (_miniMapMarker == null)
            {
                if (Position != Vector3.Zero)
                {
                    _miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                        .Where(marker => marker != null && marker.NameHash == MapMarkerNameHash &&
                            Position.Distance(marker.Position) < MaxSearchDistance)
                        .OrderBy(o => o.Position.Distance(ZetaDia.Me.Position)).FirstOrDefault();
                }
                else
                {
                    _miniMapMarker = ZetaDia.Minimap.Markers.CurrentWorldMarkers
                        .Where(marker => marker != null && marker.NameHash == MapMarkerNameHash)
                        .OrderBy(o => o.Position.Distance(ZetaDia.Me.Position)).FirstOrDefault();
                }
            }
            if (_miniMapMarker != null && _miniMapMarker.Position != Vector3.Zero)
            {
                _mapMarkerLastPosition = _miniMapMarker.Position;
            }

        }
 public static string GetDisplayName(this MinimapMarker minimapMarker)
 {
     return(string.Empty);
 }
        public override void ResetCachedDone()
        {
            _isDone = false;

            _behaviorStartTime = DateTime.UtcNow;
            _lastPosition = Vector3.Zero;
            _stuckStart = DateTime.UtcNow;
            _lastCheckedStuck = DateTime.UtcNow;
            _lastMoveResult = MoveResult.Moved;
            _completedInteractAttempts = 0;
            _startWorldId = ZetaDia.CurrentWorldId;
            _miniMapMarker = null;
            _mapMarkerLastPosition = Vector3.Zero;
            _interactObject = null;

            base.ResetCachedDone();
        }