clear level and more runs

hectorgimenez · hectorgimenez · Nov 9, 2024 · Aug 16, 2024 · Aug 17, 2024 · Aug 17, 2024
commit ee6dd0a851959825898af4026b77fe944be361dc
diff --git a/internal/v2/action/clear_level.go b/internal/v2/action/clear_level.go
@@ -0,0 +1,104 @@
+package action
+
+import (
+	"errors"
+
+	"github.com/hectorgimenez/d2go/pkg/data"
+	"github.com/hectorgimenez/d2go/pkg/data/stat"
+	"github.com/hectorgimenez/koolo/internal/game"
+	"github.com/hectorgimenez/koolo/internal/v2/context"
+)
+
+func ClearCurrentLevel(openChests bool, filter data.MonsterFilter) error {
+	ctx := context.Get()
+	ctx.ContextDebug.LastAction = "ClearLevel"
+
+	for _, r := range ctx.PathFinder.OptimizeRoomsTraverseOrder() {
+		err := clearRoom(r, filter)
+		if err != nil {
+			ctx.Logger.Warn("Failed to clear room: %v", err)
+		}
+
+		if !openChests {
+			continue
+		}
+
+		for _, o := range ctx.Data.Objects {
+			if o.IsChest() && o.Selectable && r.IsInside(o.Position) {
+				err = MoveToCoords(o.Position)
+				if err != nil {
+					ctx.Logger.Warn("Failed moving to chest: %v", err)
+					continue
+				}
+				err = InteractObject(o, func() bool {
+					chest, _ := ctx.Data.Objects.FindByID(o.ID)
+					return !chest.Selectable
+				})
+				if err != nil {
+					ctx.Logger.Warn("Failed interacting with chest: %v", err)
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func clearRoom(room data.Room, filter data.MonsterFilter) error {
+	ctx := context.Get()
+
+	path, _, found := ctx.PathFinder.GetClosestWalkablePath(room.GetCenter())
+	if !found {
+		return errors.New("failed to find a path to the room center")
+	}
+
+	err := MoveToCoords(path.To())
+	if err != nil {
+		ctx.Logger.Warn("Failed moving to room center: %v", err)
+	}
+
+	for monsters := getMonstersInRoom(room, filter); len(monsters) > 0; {
+		// Check if there are monsters that can summon new monsters, and kill them first
+		targetMonster := monsters[0]
+		for _, m := range monsters {
+			if m.IsMonsterRaiser() {
+				targetMonster = m
+			}
+		}
+
+		path, _, mPathFound := ctx.PathFinder.GetPath(targetMonster.Position)
+		if mPathFound {
+			if !ctx.Data.CanTeleport() {
+				for _, o := range ctx.Data.Objects {
+					if o.IsDoor() && o.Selectable && path.Intersects(*ctx.Data, o.Position, 4) {
+						ctx.Logger.Debug("Door is blocking the path to the monster, moving closer")
+						MoveToCoords(targetMonster.Position)
+					}
+				}
+			}
+
+			ctx.Char.KillMonsterSequence(func(d game.Data) (data.UnitID, bool) {
+				m, found := d.Monsters.FindByID(targetMonster.UnitID)
+				if found && m.Stats[stat.Life] > 0 {
+					return targetMonster.UnitID, true
+				}
+				return 0, false
+			}, nil)
+		}
+	}
+
+	return nil
+}
+
+func getMonstersInRoom(room data.Room, filter data.MonsterFilter) []data.Monster {
+	ctx := context.Get()
+
+	monstersInRoom := make([]data.Monster, 0)
+	for _, m := range ctx.Data.Monsters.Enemies(filter) {
+		if room.IsInside(m.Position) || ctx.PathFinder.DistanceFromMe(m.Position) < 30 {
+			monstersInRoom = append(monstersInRoom, m)
+		}
+	}
+
+	return monstersInRoom
+}
diff --git a/internal/v2/action/town.go b/internal/v2/action/town.go
@@ -3,10 +3,11 @@ package action
 import (
 	"github.com/hectorgimenez/d2go/pkg/data/skill"
 	"github.com/hectorgimenez/koolo/internal/v2/action/step"
+	"github.com/hectorgimenez/koolo/internal/v2/context"
 )
 
 func PreRun(firstRun bool) error {
-	//ctx := context.Get()
+	ctx := context.Get()
 
 	DropMouseItem()
 	step.SetSkill(skill.Vigor)
@@ -16,33 +17,33 @@ func PreRun(firstRun bool) error {
 		Stash(firstRun)
 	}
 
-	//UpdateQuestLog()
+	UpdateQuestLog()
 	IdentifyAll(firstRun)
 	VendorRefill(false, true)
 	Stash(firstRun)
 	Gamble()
 	Stash(false)
 	CubeRecipes()
 
-	//if ctx.CharacterCfg.Game.Leveling.EnsurePointsAllocation {
-	//	ResetStats()
-	//	EnsureStatPoints()
-	//	EnsureSkillPoints()
-	//}
-	//
-	//if ctx.CharacterCfg.Game.Leveling.EnsureKeyBinding {
-	//	EnsureSkillBindings()
-	//}
+	if ctx.CharacterCfg.Game.Leveling.EnsurePointsAllocation {
+		ResetStats()
+		EnsureStatPoints()
+		EnsureSkillPoints()
+	}
+
+	if ctx.CharacterCfg.Game.Leveling.EnsureKeyBinding {
+		EnsureSkillBindings()
+	}
 
 	HealAtNPC()
 	ReviveMerc()
-	//HireMerc()
+	HireMerc()
 
 	return Repair()
 }
 
 func InRunReturnTownRoutine() error {
-	//ctx := context.Get()
+	ctx := context.Get()
 
 	ReturnTown()
 	step.SetSkill(skill.Vigor)
@@ -54,18 +55,18 @@ func InRunReturnTownRoutine() error {
 	Stash(false)
 	CubeRecipes()
 
-	//if ctx.CharacterCfg.Game.Leveling.EnsurePointsAllocation {
-	//	EnsureStatPoints()
-	//	EnsureSkillPoints()
-	//}
-	//
-	//if ctx.CharacterCfg.Game.Leveling.EnsureKeyBinding {
-	//	EnsureSkillBindings()
-	//}
+	if ctx.CharacterCfg.Game.Leveling.EnsurePointsAllocation {
+		EnsureStatPoints()
+		EnsureSkillPoints()
+	}
+
+	if ctx.CharacterCfg.Game.Leveling.EnsureKeyBinding {
+		EnsureSkillBindings()
+	}
 
 	HealAtNPC()
 	ReviveMerc()
-	//HireMerc()
+	HireMerc()
 	Repair()
 
 	return UsePortalInTown()

diff --git a/internal/v2/pather/path.go b/internal/v2/pather/path.go
@@ -39,3 +39,11 @@ func (p Pather) Intersects(d game.Data, position data.Position, padding int) boo
 
 	return false
 }
+
+func (p Pather) To() data.Position {
+	if len(p) == 0 {
+		return data.Position{}
+	}
+
+	return data.Position{X: p[len(p)-1].(*Tile).X, Y: p[len(p)-1].(*Tile).Y}
+}
diff --git a/internal/v2/pather/path_finder.go b/internal/v2/pather/path_finder.go
@@ -26,8 +26,7 @@ func NewPathFinder(gr *game.MemoryReader, data *game.Data, hid *game.HID, cfg *c
 	return &PathFinder{gr: gr, hid: hid, cfg: cfg, data: data}
 }
 
-// The GetPath method definition, combined and corrected
-func (pf *PathFinder) GetPath(to data.Position, blacklistedCoords ...[2]int) (path Pather, distance int, found bool) {
+func (pf *PathFinder) GetPathFrom(from, to data.Position, blacklistedCoords ...[2]int) (path Pather, distance int, found bool) {
 	outsideCurrentLevel := outsideBoundary(pf.data, to)
 	collisionGrid := pf.data.CollisionGrid
 
@@ -98,7 +97,7 @@ func (pf *PathFinder) GetPath(to data.Position, blacklistedCoords ...[2]int) (pa
 	}
 
 	// Convert to relative coordinates (Current player position)
-	fromX, fromY := relativePosition(pf.data, pf.data.PlayerUnit.Position, collisionGridOffset)
+	fromX, fromY := relativePosition(pf.data, from, collisionGridOffset)
 
 	// Convert to relative coordinates (Target position)
 	toX, toY := relativePosition(pf.data, to, collisionGridOffset)
@@ -162,6 +161,10 @@ func (pf *PathFinder) GetPath(to data.Position, blacklistedCoords ...[2]int) (pa
 	return p, len(p), found
 }
 
+func (pf *PathFinder) GetPath(to data.Position, blacklistedCoords ...[2]int) (path Pather, distance int, found bool) {
+	return pf.GetPathFrom(pf.data.PlayerUnit.Position, to, blacklistedCoords...)
+}
+
 func ensureValueInCG(val, cgSize int) int {
 	if val < 0 {
 		return 0
@@ -175,6 +178,10 @@ func ensureValueInCG(val, cgSize int) int {
 }
 
 func (pf *PathFinder) GetClosestWalkablePath(dest data.Position, blacklistedCoords ...[2]int) (path Pather, distance int, found bool) {
+	return pf.GetClosestWalkablePathFrom(pf.data.PlayerUnit.Position, dest, blacklistedCoords...)
+}
+
+func (pf *PathFinder) GetClosestWalkablePathFrom(from, dest data.Position, blacklistedCoords ...[2]int) (path Pather, distance int, found bool) {
 	if IsWalkable(dest, pf.data.AreaOrigin, pf.data.CollisionGrid) || outsideBoundary(pf.data, dest) {
 		path, distance, found = pf.GetPath(dest, blacklistedCoords...)
 		if found {
@@ -193,7 +200,7 @@ func (pf *PathFinder) GetClosestWalkablePath(dest data.Position, blacklistedCoor
 					cgY := dest.Y - pf.data.AreaOrigin.Y + j
 					cgX := dest.X - pf.data.AreaOrigin.X + i
 					if cgX > 0 && cgY > 0 && len(pf.data.CollisionGrid) > cgY && len(pf.data.CollisionGrid[cgY]) > cgX && pf.data.CollisionGrid[cgY][cgX] {
-						return pf.GetPath(data.Position{
+						return pf.GetPathFrom(from, data.Position{
 							X: dest.X + i,
 							Y: dest.Y + j,
 						}, blacklistedCoords...)
@@ -235,16 +242,7 @@ func (pf *PathFinder) MoveCharacter(x, y int) {
 }
 
 func (pf *PathFinder) GameCoordsToScreenCords(destinationX, destinationY int) (int, int) {
-	// Calculate diff between current player position and destination
-	diffX := destinationX - pf.data.PlayerUnit.Position.X
-	diffY := destinationY - pf.data.PlayerUnit.Position.Y
-
-	// Transform cartesian movement (World) to isometric (screen)
-	// Helpful documentation: https://clintbellanger.net/articles/isometric_math/
-	screenX := int((float32(diffX-diffY) * 19.8) + float32(pf.gr.GameAreaSizeX/2))
-	screenY := int((float32(diffX+diffY) * 9.9) + float32(pf.gr.GameAreaSizeY/2))
-
-	return screenX, screenY
+	return pf.gameCoordsToScreenCords(pf.data.PlayerUnit.Position.X, pf.data.PlayerUnit.Position.Y, destinationX, destinationY)
 }
 
 func (pf *PathFinder) gameCoordsToScreenCords(playerX, playerY, destinationX, destinationY int) (int, int) {
@@ -274,6 +272,57 @@ func (pf *PathFinder) DistanceFromMe(p data.Position) int {
 	return DistanceFromPoint(pf.data.PlayerUnit.Position, p)
 }
 
+func (pf *PathFinder) OptimizeRoomsTraverseOrder() []data.Room {
+	distanceMatrix := make(map[data.Room]map[data.Room]int)
+
+	for _, room1 := range pf.data.Rooms {
+		distanceMatrix[room1] = make(map[data.Room]int)
+		for _, room2 := range pf.data.Rooms {
+			if room1 != room2 {
+				_, distance, found := pf.GetClosestWalkablePathFrom(room1.GetCenter(), room2.GetCenter())
+				if found {
+					distanceMatrix[room1][room2] = distance
+				} else {
+					distanceMatrix[room1][room2] = math.MaxInt
+				}
+			} else {
+				distanceMatrix[room1][room2] = 0
+			}
+		}
+	}
+
+	currentRoom := data.Room{}
+	for _, r := range pf.data.Rooms {
+		if r.IsInside(pf.data.PlayerUnit.Position) {
+			currentRoom = r
+		}
+	}
+
+	visited := make(map[data.Room]bool)
+	order := []data.Room{currentRoom}
+	visited[currentRoom] = true
+
+	for len(order) < len(pf.data.Rooms) {
+		nextRoom := data.Room{}
+		minDistance := math.MaxInt
+
+		// Find the nearest unvisited room
+		for _, room := range pf.data.Rooms {
+			if !visited[room] && distanceMatrix[currentRoom][room] < minDistance {
+				nextRoom = room
+				minDistance = distanceMatrix[currentRoom][room]
+			}
+		}
+
+		// Add the next room to the order of visit
+		order = append(order, nextRoom)
+		visited[nextRoom] = true
+		currentRoom = nextRoom
+	}
+
+	return order
+}
+
 func relativePosition(d *game.Data, p data.Position, cgOffset data.Position) (int, int) {
 	x, y := p.X-d.AreaOrigin.X, p.Y-d.AreaOrigin.Y
 

diff --git a/internal/v2/run/ancient_tunnels.go b/internal/v2/run/ancient_tunnels.go
@@ -0,0 +1,48 @@
+package run
+
+import (
+	"github.com/hectorgimenez/d2go/pkg/data"
+	"github.com/hectorgimenez/d2go/pkg/data/area"
+	"github.com/hectorgimenez/koolo/internal/config"
+	"github.com/hectorgimenez/koolo/internal/v2/action"
+	"github.com/hectorgimenez/koolo/internal/v2/context"
+)
+
+type AncientTunnels struct {
+	ctx *context.Status
+}
+
+func NewAncientTunnels() *AncientTunnels {
+	return &AncientTunnels{
+		ctx: context.Get(),
+	}
+}
+
+func (a AncientTunnels) Name() string {
+	return string(config.AncientTunnelsRun)
+}
+
+func (a AncientTunnels) Run() error {
+	openChests := a.ctx.CharacterCfg.Game.AncientTunnels.OpenChests
+	onlyElites := a.ctx.CharacterCfg.Game.AncientTunnels.FocusOnElitePacks
+	filter := data.MonsterAnyFilter()
+
+	if onlyElites {
+		filter = data.MonsterEliteFilter()
+	}
+
+	err := action.WayPoint(area.LostCity) // Moving to starting point (Lost City)
+	if err != nil {
+		return err
+	}
+
+	err = action.MoveToArea(area.AncientTunnels) // Travel to ancient tunnels
+	if err != nil {
+		return err
+	}
+	action.OpenTPIfLeader()
+
+	// Clear Ancient Tunnels
+
+	return action.ClearCurrentLevel(openChests, filter)
+}